Add support for RTCConfiguration.iceCandidatePoolSize.

content/renderer/media/peer_connection_tracker.cc

 // Copyright (c) 2013 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/peer_connection_tracker.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 155 matching lines @@
     break;
   case webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire:
     policy_str = "require";
     break;
   default:
     NOTREACHED();
   };
   return policy_str;
 }
 
+static std::string SerializeConfiguration(
+    const webrtc::PeerConnectionInterface::RTCConfiguration& config) {
+  std::ostringstream oss;
+  // TODO(hbos): Add serialization of certificate.
+  oss << "{ iceServers: " << SerializeServers(config.servers) << ", "
+      << "iceTransportPolicy: " << SerializeIceTransportType(config.type)
+      << ", "
+      << "bundlePolicy: " << SerializeBundlePolicy(config.bundle_policy) << ", "
+      << "rtcpMuxPolicy: " << SerializeRtcpMuxPolicy(config.rtcp_mux_policy)
+      << "iceCandidatePoolSize: " << config.ice_candidate_pool_size << " }";
+  return oss.str();
+}
+
 #define GET_STRING_OF_STATE(state)                \
   case WebRTCPeerConnectionHandlerClient::state:  \
     result = #state;                              \
     break;
 
 static const char* GetSignalingStateString(
     WebRTCPeerConnectionHandlerClient::SignalingState state) {
   const char* result = "";
   switch (state) {
     GET_STRING_OF_STATE(SignalingStateStable)
@@ skipping 235 matching lines @@
     RTCPeerConnectionHandler* pc_handler,
     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
     const blink::WebMediaConstraints& constraints,
     const blink::WebFrame* frame) {
   DCHECK(main_thread_.CalledOnValidThread());
   DCHECK_EQ(GetLocalIDForHandler(pc_handler), -1);
   DVLOG(1) << "PeerConnectionTracker::RegisterPeerConnection()";
   PeerConnectionInfo info;
 
   info.lid = GetNextLocalID();
-  info.rtc_configuration =
-      "{ iceServers: " +  SerializeServers(config.servers) + ", " +
-      "iceTransportPolicy: " + SerializeIceTransportType(config.type) + ", " +
-      "bundlePolicy: " + SerializeBundlePolicy(config.bundle_policy) + ", " +
-      "rtcpMuxPolicy: " + SerializeRtcpMuxPolicy(config.rtcp_mux_policy) + " }";
+  info.rtc_configuration = SerializeConfiguration(config);
 
   info.constraints = SerializeMediaConstraints(constraints);
   if (frame)
     info.url = frame->document().url().string().utf8();
   else
     info.url = "test:testing";
   SendTarget()->Send(new PeerConnectionTrackerHost_AddPeerConnection(info));
 
   peer_connection_id_map_.insert(std::make_pair(pc_handler, info.lid));
 }
@@ skipping 79 matching lines @@
 }
 
 void PeerConnectionTracker::TrackSetConfiguration(
     RTCPeerConnectionHandler* pc_handler,
     const webrtc::PeerConnectionInterface::RTCConfiguration& config) {
   DCHECK(main_thread_.CalledOnValidThread());
   int id = GetLocalIDForHandler(pc_handler);
   if (id == -1)
     return;
 
-  std::ostringstream result;
-  result << "servers: " << SerializeServers(config.servers)
-         << "iceTransportType: " << SerializeIceTransportType(config.type)
-         << "bundlePolicy: " << SerializeBundlePolicy(config.bundle_policy)
-         << "rtcpMuxPolicy: " << SerializeRtcpMuxPolicy(config.rtcp_mux_policy)
-         << "}";
-
-  SendPeerConnectionUpdate(id, "setConfiguration", result.str());
+  SendPeerConnectionUpdate(id, "setConfiguration",
+                           SerializeConfiguration(config));
 }
 
 void PeerConnectionTracker::TrackAddIceCandidate(
       RTCPeerConnectionHandler* pc_handler,
       const blink::WebRTCICECandidate& candidate,
       Source source,
       bool succeeded) {
   DCHECK(main_thread_.CalledOnValidThread());
   int id = GetLocalIDForHandler(pc_handler);
   if (id == -1)
@@ skipping 185 matching lines @@
   DCHECK(main_thread_.CalledOnValidThread());
   SendTarget()->Send(new PeerConnectionTrackerHost_UpdatePeerConnection(
       local_id, std::string(callback_type), value));
 }
 
 void PeerConnectionTracker::OverrideSendTargetForTesting(RenderThread* target) {
   send_target_for_test_ = target;
 }
 
 }  // namespace content