Create the API that returns the RTCConfiguration of the PeerConnection.

content/renderer/media/rtc_peer_connection_handler.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 
 #include <string.h>
 
 #include <string>
 #include <utility>
@@ skipping 225 matching lines @@
 void GetNativeRtcConfiguration(
     const blink::WebRTCConfiguration& blink_config,
     webrtc::PeerConnectionInterface::RTCConfiguration* webrtc_config) {
   DCHECK(webrtc_config);
 
   webrtc_config->servers.clear();
   for (const blink::WebRTCIceServer& blink_server : blink_config.iceServers) {
     webrtc::PeerConnectionInterface::IceServer server;
     server.username = blink_server.username.utf8();
     server.password = blink_server.credential.utf8();
-    server.uri = blink_server.url.string().utf8();
+    for (const blink::WebURL& url : blink_server.urls) {
+      server.urls.push_back(url.string().utf8());
+    }
     webrtc_config->servers.push_back(server);
   }
 
   switch (blink_config.iceTransportPolicy) {
     case blink::WebRTCIceTransportPolicy::kNone:
       webrtc_config->type = webrtc::PeerConnectionInterface::kNone;
       break;
     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.bundlePolicy) {
     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.rtcpMuxPolicy) {
     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->certificates.clear();
   for (const std::unique_ptr<blink::WebRTCCertificate>& blink_certificate :
        blink_config.certificates) {
     webrtc_config->certificates.push_back(
         static_cast<RTCCertificate*>(blink_certificate.get())
             ->rtcCertificate());
   }
 
   webrtc_config->ice_candidate_pool_size = blink_config.iceCandidatePoolSize;
 }
 
+blink::WebRTCConfiguration ToBlinkRtcConfiguration(
+    const webrtc::PeerConnectionInterface::RTCConfiguration& webrtc_config) {
+  blink::WebRTCConfiguration blink_config;
+  blink::WebVector<blink::WebRTCIceServer> iceServers(
+      webrtc_config.servers.size());
+  for (size_t i = 0; i < webrtc_config.servers.size(); ++i) {
+    const webrtc::PeerConnectionInterface::IceServer& ice_server =
+        webrtc_config.servers[i];
+    blink::WebRTCIceServer blink_server;
+    blink::WebVector<blink::WebURL> blink_urls(ice_server.urls.size());
+    for (size_t j = 0; j < ice_server.urls.size(); ++j)
+      blink_urls[j] = GURL(ice_server.urls[j]);
+    blink_server.urls = std::move(blink_urls);
+    blink_server.username = blink::WebString::fromUTF8(ice_server.username);
+    blink_server.credential = blink::WebString::fromUTF8(ice_server.password);
+    iceServers[i] = blink_server;
+  }
+  blink_config.iceServers = std::move(iceServers);
+
+  switch (webrtc_config.type) {
+    case webrtc::PeerConnectionInterface::kNone:
+      blink_config.iceTransportPolicy = blink::WebRTCIceTransportPolicy::kNone;
+      break;
+    case webrtc::PeerConnectionInterface::kRelay:
+      blink_config.iceTransportPolicy = blink::WebRTCIceTransportPolicy::kRelay;
+      break;
+    case webrtc::PeerConnectionInterface::kAll:
+      blink_config.iceTransportPolicy = blink::WebRTCIceTransportPolicy::kAll;
+      break;
+    case webrtc::PeerConnectionInterface::kNoHost:
+      NOTREACHED();
+  }
+
+  switch (webrtc_config.bundle_policy) {
+    case webrtc::PeerConnectionInterface::kBundlePolicyBalanced:
+      blink_config.bundlePolicy = blink::WebRTCBundlePolicy::kBalanced;
+      break;
+    case webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle:
+      blink_config.bundlePolicy = blink::WebRTCBundlePolicy::kMaxBundle;
+      break;
+    case webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat:
+      blink_config.bundlePolicy = blink::WebRTCBundlePolicy::kMaxCompat;
+      break;
+  }
+
+  switch (webrtc_config.rtcp_mux_policy) {
+    case webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate:
+      blink_config.rtcpMuxPolicy = blink::WebRTCRtcpMuxPolicy::kNegotiate;
+      break;
+    case webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire:
+      blink_config.rtcpMuxPolicy = blink::WebRTCRtcpMuxPolicy::kRequire;
+      break;
+  }
+
+  blink::WebVector<std::unique_ptr<blink::WebRTCCertificate>> certificates(
+      webrtc_config.certificates.size());
+  for (size_t i = 0; i < webrtc_config.certificates.size(); ++i) {
+    certificates[i] =
+        base::MakeUnique<RTCCertificate>(webrtc_config.certificates[i]);
+  }
+  blink_config.certificates = std::move(certificates);
+  return blink_config;
+}
+
 void CopyConstraintsIntoRtcConfiguration(
     const blink::WebMediaConstraints constraints,
     webrtc::PeerConnectionInterface::RTCConfiguration* configuration) {
   // Copy info from constraints into configuration, if present.
   if (constraints.isEmpty()) {
     return;
   }
 
   bool the_value;
   if (GetConstraintValueAsBoolean(
@@ skipping 1135 matching lines @@
   blink::WebRTCError blink_error;
   bool ret =
       native_peer_connection_->SetConfiguration(configuration_, &webrtc_error);
   // The boolean return value is made redundant by the error output param; just
   // DCHECK that they're consistent.
   DCHECK_EQ(ret, webrtc_error.type() == webrtc::RTCErrorType::NONE);
   ConvertToWebKitRTCError(webrtc_error, &blink_error);
   return blink_error.type();
 }
 
+blink::WebRTCConfiguration RTCPeerConnectionHandler::getConfiguration() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  webrtc::PeerConnectionInterface::RTCConfiguration webrtc_config =
+      native_peer_connection_->GetConfiguration();
+  return ToBlinkRtcConfiguration(webrtc_config);
+}
+
 bool RTCPeerConnectionHandler::addICECandidate(
     const blink::WebRTCVoidRequest& request,
     const blink::WebRTCICECandidate& candidate) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::addICECandidate");
   // Libjingle currently does not accept callbacks for addICECandidate.
   // For that reason we are going to call callbacks from here.
 
   // TODO(tommi): Instead of calling addICECandidate here, we can do a
   // PostTaskAndReply kind of a thing.
@@ skipping 535 matching lines @@
 }
 
 void RTCPeerConnectionHandler::ResetUMAStats() {
   DCHECK(thread_checker_.CalledOnValidThread());
   num_local_candidates_ipv6_ = 0;
   num_local_candidates_ipv4_ = 0;
   ice_connection_checking_start_ = base::TimeTicks();
   memset(ice_state_seen_, 0, sizeof(ice_state_seen_));
 }
 }  // namespace content