Merge RTCConfiguration into WebRTCConfiguration

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 57 matching lines @@
 #include "modules/peerconnection/RTCSessionDescriptionInit.h"
 #include "modules/peerconnection/RTCSessionDescriptionRequestImpl.h"
 #include "modules/peerconnection/RTCSessionDescriptionRequestPromiseImpl.h"
 #include "modules/peerconnection/RTCStatsCallback.h"
 #include "modules/peerconnection/RTCStatsReport.h"
 #include "modules/peerconnection/RTCStatsRequestImpl.h"
 #include "modules/peerconnection/RTCVoidRequestImpl.h"
 #include "modules/peerconnection/RTCVoidRequestPromiseImpl.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/peerconnection/RTCAnswerOptionsPlatform.h"
-#include "platform/peerconnection/RTCConfiguration.h"
 #include "platform/peerconnection/RTCOfferOptionsPlatform.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCryptoAlgorithmParams.h"
 #include "public/platform/WebMediaStream.h"
 #include "public/platform/WebRTCAnswerOptions.h"
 #include "public/platform/WebRTCCertificate.h"
 #include "public/platform/WebRTCCertificateGenerator.h"
 #include "public/platform/WebRTCConfiguration.h"
 #include "public/platform/WebRTCDataChannelHandler.h"
 #include "public/platform/WebRTCDataChannelInit.h"
@@ skipping 122 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;
 };
 
-RTCConfiguration* parseConfiguration(const Dictionary& configuration,
-                                     ExceptionState& exceptionState,
-                                     RtcpMuxPolicy* selectedRtcpMuxPolicy) {
+WebRTCConfiguration parseConfiguration(const Dictionary& configuration,
+                                       ExceptionState& exceptionState,
+                                       RtcpMuxPolicy* selectedRtcpMuxPolicy) {
+  WebRTCConfiguration rtcConfiguration;
   if (configuration.isUndefinedOrNull())
-    return 0;
+    return WebRTCConfiguration();
 
-  RTCIceTransports iceTransports = RTCIceTransportsAll;
+  WebRTCIceTransports iceTransports = WebRTCIceTransports::kAll;
   String iceTransportsString;
   if (DictionaryHelper::get(configuration, "iceTransports",
                             iceTransportsString)) {
     if (iceTransportsString == "none") {
-      iceTransports = RTCIceTransportsNone;
+      iceTransports = WebRTCIceTransports::kNone;
     } else if (iceTransportsString == "relay") {
-      iceTransports = RTCIceTransportsRelay;
+      iceTransports = WebRTCIceTransports::kRelay;
     } else if (iceTransportsString != "all") {
       exceptionState.throwTypeError("Malformed RTCIceTransports");
-      return 0;
+      return WebRTCConfiguration();
     }
   }
 
   ArrayValue iceServers;
   bool ok = DictionaryHelper::get(configuration, "iceServers", iceServers);
   if (!ok || iceServers.isUndefinedOrNull()) {
     exceptionState.throwTypeError("Malformed RTCConfiguration");
-    return 0;
+    return WebRTCConfiguration();
   }
 
   size_t numberOfServers;
   ok = iceServers.length(numberOfServers);
   if (!ok) {
     exceptionState.throwTypeError("Malformed RTCConfiguration");
-    return 0;
+    return WebRTCConfiguration();
   }
 
-  RTCBundlePolicy bundlePolicy = RTCBundlePolicyBalanced;
+  WebRTCBundlePolicy bundlePolicy = WebRTCBundlePolicy::kBalanced;
   String bundlePolicyString;
   if (DictionaryHelper::get(configuration, "bundlePolicy",
                             bundlePolicyString)) {
     if (bundlePolicyString == "max-compat") {
-      bundlePolicy = RTCBundlePolicyMaxCompat;
+      bundlePolicy = WebRTCBundlePolicy::kMaxCompat;
     } else if (bundlePolicyString == "max-bundle") {
-      bundlePolicy = RTCBundlePolicyMaxBundle;
+      bundlePolicy = WebRTCBundlePolicy::kMaxBundle;
     } else if (bundlePolicyString != "balanced") {
       exceptionState.throwTypeError("Malformed RTCBundlePolicy");
-      return 0;
+      return WebRTCConfiguration();
     }
   }
 
   // For the histogram value of "WebRTC.PeerConnection.SelectedRtcpMuxPolicy".
   *selectedRtcpMuxPolicy = RtcpMuxPolicyDefault;
-  RTCRtcpMuxPolicy rtcpMuxPolicy = RTCRtcpMuxPolicyNegotiate;
+  WebRTCRtcpMuxPolicy rtcpMuxPolicy = WebRTCRtcpMuxPolicy::kNegotiate;
   String rtcpMuxPolicyString;
   if (DictionaryHelper::get(configuration, "rtcpMuxPolicy",
                             rtcpMuxPolicyString)) {
     if (rtcpMuxPolicyString == "require") {
       *selectedRtcpMuxPolicy = RtcpMuxPolicyRequire;
-      rtcpMuxPolicy = RTCRtcpMuxPolicyRequire;
+      rtcpMuxPolicy = WebRTCRtcpMuxPolicy::kRequire;
     } else if (rtcpMuxPolicyString == "negotiate") {
       *selectedRtcpMuxPolicy = RtcpMuxPolicyNegotiate;
-      rtcpMuxPolicy = RTCRtcpMuxPolicyNegotiate;
+      rtcpMuxPolicy = WebRTCRtcpMuxPolicy::kNegotiate;
     } else {
       exceptionState.throwTypeError("Malformed RTCRtcpMuxPolicy");
-      return 0;
+      return WebRTCConfiguration();
     }
   }
 
-  RTCConfiguration* rtcConfiguration = RTCConfiguration::create();
-  rtcConfiguration->setIceTransports(iceTransports);
-  rtcConfiguration->setBundlePolicy(bundlePolicy);
-  rtcConfiguration->setRtcpMuxPolicy(rtcpMuxPolicy);
+  rtcConfiguration.iceTransports = iceTransports;
+  rtcConfiguration.bundlePolicy = bundlePolicy;
+  rtcConfiguration.rtcpMuxPolicy = rtcpMuxPolicy;
 
   for (size_t i = 0; i < numberOfServers; ++i) {
     Dictionary iceServer;
     ok = iceServers.get(i, iceServer);
     if (!ok) {
       exceptionState.throwTypeError("Malformed RTCIceServer");
-      return 0;
+      return WebRTCConfiguration();
     }
 
     Vector<String> names;
     iceServer.getPropertyNames(names);
 
     Vector<String> urlStrings;
     if (names.contains("urls")) {
       if (!DictionaryHelper::get(iceServer, "urls", urlStrings) ||
           !urlStrings.size()) {
         String urlString;
         if (DictionaryHelper::get(iceServer, "urls", urlString)) {
           urlStrings.append(urlString);
         } else {
           exceptionState.throwTypeError("Malformed RTCIceServer");
-          return 0;
+          return WebRTCConfiguration();
         }
       }
     } else if (names.contains("url")) {
       String urlString;
       if (DictionaryHelper::get(iceServer, "url", urlString)) {
         urlStrings.append(urlString);
       } else {
         exceptionState.throwTypeError("Malformed RTCIceServer");
-        return 0;
+        return WebRTCConfiguration();
       }
     } else {
       exceptionState.throwTypeError("Malformed RTCIceServer");
-      return 0;
+      return WebRTCConfiguration();
     }
 
     String username, credential;
     DictionaryHelper::get(iceServer, "username", username);
     DictionaryHelper::get(iceServer, "credential", credential);
 
+    Vector<WebRTCIceServer> iceServers;
     for (Vector<String>::iterator iter = urlStrings.begin();
          iter != urlStrings.end(); ++iter) {
       KURL url(KURL(), *iter);
       if (!url.isValid() ||
           !(url.protocolIs("turn") || url.protocolIs("turns") ||
             url.protocolIs("stun"))) {
         exceptionState.throwTypeError("Malformed URL");
-        return 0;
+        return WebRTCConfiguration();
       }
-
-      rtcConfiguration->appendServer(
-          RTCIceServer::create(url, username, credential));
+      iceServers.append(WebRTCIceServer{url, username, credential});
     }
+    rtcConfiguration.iceServers = iceServers;
   }
 
   ArrayValue certificates;
   if (DictionaryHelper::get(configuration, "certificates", certificates) &&
       !certificates.isUndefinedOrNull()) {
     size_t numberOfCertificates;
     certificates.length(numberOfCertificates);
+    WebVector<std::unique_ptr<WebRTCCertificate>> certificatesCopy(
+        numberOfCertificates);
     for (size_t i = 0; i < numberOfCertificates; ++i) {
       RTCCertificate* certificate = nullptr;
 
       Dictionary dictCert;
       certificates.get(i, dictCert);
       v8::Local<v8::Value> valCert = dictCert.v8Value();
       if (!valCert.IsEmpty()) {
         certificate = V8RTCCertificate::toImplWithTypeCheck(
             configuration.isolate(), valCert);
       }
       if (!certificate) {
         exceptionState.throwTypeError("Malformed sequence<RTCCertificate>");
-        return 0;
+        return WebRTCConfiguration();
       }
 
-      rtcConfiguration->appendCertificate(
-          certificate->certificateShallowCopy());
+      certificatesCopy[i] = certificate->certificateShallowCopy();
     }
+    rtcConfiguration.certificates = std::move(certificatesCopy);
   }
   return rtcConfiguration;
 }
 
 RTCOfferOptionsPlatform* parseOfferOptions(const Dictionary& options) {
   if (options.isUndefinedOrNull())
     return 0;
 
   Vector<String> propertyNames;
   options.getPropertyNames(propertyNames);
@@ skipping 78 matching lines @@
   if (mediaConstraints.isObject())
     UseCounter::count(context,
                       UseCounter::RTCPeerConnectionConstructorConstraints);
   else
     UseCounter::count(context,
                       UseCounter::RTCPeerConnectionConstructorCompliant);
 
   // Record the RtcpMuxPolicy for histogram
   // "WebRTC.PeerConnection.SelectedRtcpMuxPolicy".
   RtcpMuxPolicy selectedRtcpMuxPolicy = RtcpMuxPolicyDefault;
-  RTCConfiguration* configuration = parseConfiguration(
+  WebRTCConfiguration configuration = parseConfiguration(
       rtcConfiguration, exceptionState, &selectedRtcpMuxPolicy);
   if (exceptionState.hadException())
     return 0;
 
   // Make sure no certificates have expired.
-  if (configuration && configuration->numberOfCertificates() > 0) {
+  if (configuration.certificates.size() > 0) {
     DOMTimeStamp now = convertSecondsToDOMTimeStamp(currentTime());
-    for (size_t i = 0; i < configuration->numberOfCertificates(); ++i) {
-      DOMTimeStamp expires = configuration->certificate(i)->expires();
+    for (const std::unique_ptr<WebRTCCertificate>& certificate :
+         configuration.certificates) {
+      DOMTimeStamp expires = certificate->expires();
       if (expires <= now) {
+        // TODO(hbos): Per https://w3c.github.io/webrtc-pc/#operation this
+        // should throw InvalidAccessError, not InvalidStateError.
         exceptionState.throwDOMException(InvalidStateError,
                                          "Expired certificate(s).");
         return 0;
       }
     }
   }
 
   MediaErrorState mediaErrorState;
   WebMediaConstraints constraints =
       MediaConstraintsImpl::create(context, mediaConstraints, mediaErrorState);
   if (mediaErrorState.hadException()) {
     mediaErrorState.raiseException(exceptionState);
     return 0;
   }
 
   RTCPeerConnection* peerConnection = new RTCPeerConnection(
       context, configuration, constraints, exceptionState);
   peerConnection->suspendIfNeeded();
   if (exceptionState.hadException())
     return 0;
 
   peerConnection->m_peerHandler->logSelectedRtcpMuxPolicy(
       selectedRtcpMuxPolicy);
 
   return peerConnection;
 }
 
 RTCPeerConnection::RTCPeerConnection(ExecutionContext* context,
-                                     RTCConfiguration* configuration,
+                                     const WebRTCConfiguration& configuration,
                                      WebMediaConstraints constraints,
                                      ExceptionState& exceptionState)
     : ActiveScriptWrappable(this),
       ActiveDOMObject(context),
       m_signalingState(SignalingStateStable),
       m_iceGatheringState(ICEGatheringStateNew),
       m_iceConnectionState(ICEConnectionStateNew),
       m_dispatchScheduledEventRunner(
           AsyncMethodRunner<RTCPeerConnection>::create(
               this,
@@ skipping 303 matching lines @@
   return RTCSessionDescription::create(webSessionDescription);
 }
 
 void RTCPeerConnection::updateIce(const Dictionary& rtcConfiguration,
                                   const Dictionary& mediaConstraints,
                                   ExceptionState& exceptionState) {
   if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
     return;
 
   RtcpMuxPolicy selectedRtcpMuxPolicy = RtcpMuxPolicyDefault;
-  RTCConfiguration* configuration = parseConfiguration(
+  WebRTCConfiguration configuration = parseConfiguration(
       rtcConfiguration, exceptionState, &selectedRtcpMuxPolicy);
 
   if (exceptionState.hadException())
     return;
 
   MediaErrorState mediaErrorState;
   if (mediaErrorState.hadException()) {
     mediaErrorState.raiseException(exceptionState);
     return;
   }
@@ skipping 659 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