Converts RTCOfferOptions to constriants in the glue code for createOffer.

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 "base/strings/utf_string_conversions.h"
 #include "content/common/media/peer_connection_tracker_messages.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "content/renderer/render_thread_impl.h"
@@ skipping 103 matching lines @@
     for (size_t i = 0; i < tracks.size(); ++i) {
       result += SerializeMediaStreamComponent(tracks[i]);
       if (i != tracks.size() - 1)
         result += ", ";
     }
     result += "]";
   }
   return result;
 }
 
+static std::string SerializeIceTransportType(
+    webrtc::PeerConnectionInterface::IceTransportsType type) {
+  string transport_type;
+  switch (type) {
+  case webrtc::PeerConnectionInterface::kNone:
+    transport_type = "none";
+    break;
+  case webrtc::PeerConnectionInterface::kRelay:
+    transport_type = "relay";
+    break;
+  case webrtc::PeerConnectionInterface::kAll:
+    transport_type = "all";
+    break;
+  case webrtc::PeerConnectionInterface::kNoHost:
+    transport_type = "noHost";
+    break;
+  default:
+    NOTREACHED();
+  };
+  return transport_type;
+}
+
 #define GET_STRING_OF_STATE(state)                \
   case WebRTCPeerConnectionHandlerClient::state:  \
     result = #state;                              \
     break;
 
 static string GetSignalingStateString(
     WebRTCPeerConnectionHandlerClient::SignalingState state) {
   string result;
   switch (state) {
     GET_STRING_OF_STATE(SignalingStateStable)
@@ skipping 136 matching lines @@
 
     it->first->GetStats(
         observer,
         NULL,
         webrtc::PeerConnectionInterface::kStatsOutputLevelDebug);
   }
 }
 
 void PeerConnectionTracker::RegisterPeerConnection(
     RTCPeerConnectionHandler* pc_handler,
-    const std::vector<webrtc::PeerConnectionInterface::IceServer>& servers,
+    const webrtc::PeerConnectionInterface::RTCConfiguration& config,
     const RTCMediaConstraints& constraints,
     const blink::WebFrame* frame) {
   DVLOG(1) << "PeerConnectionTracker::RegisterPeerConnection()";
   PeerConnectionInfo info;
 
   info.lid = GetNextLocalID();
-  info.servers = SerializeServers(servers);
+  info.rtc_configuration =
+      "{ servers: " +  SerializeServers(config.servers) + ", " +
+      "iceTransportType: " + SerializeIceTransportType(config.type) + " }";
+
   info.constraints = SerializeMediaConstraints(constraints);
   info.url = frame->document().url().spec();
   RenderThreadImpl::current()->Send(
       new PeerConnectionTrackerHost_AddPeerConnection(info));
 
   DCHECK(peer_connection_id_map_.find(pc_handler) ==
          peer_connection_id_map_.end());
   peer_connection_id_map_[pc_handler] = info.lid;
 }
 
@@ skipping 41 matching lines @@
 
   string value = "type: " + type + ", sdp: " + sdp;
   SendPeerConnectionUpdate(
       pc_handler,
       source == SOURCE_LOCAL ? "setLocalDescription" : "setRemoteDescription",
       value);
 }
 
 void PeerConnectionTracker::TrackUpdateIce(
       RTCPeerConnectionHandler* pc_handler,
-      const std::vector<webrtc::PeerConnectionInterface::IceServer>& servers,
+      const webrtc::PeerConnectionInterface::RTCConfiguration& config,
       const RTCMediaConstraints& options) {
-  string servers_string = "servers: " + SerializeServers(servers);
+  string servers_string = "servers: " + SerializeServers(config.servers);
+
+  string transport_type =
+      "iceTransportType: " + SerializeIceTransportType(config.type);
+
   string constraints =
       "constraints: {" + SerializeMediaConstraints(options) + "}";
 
   SendPeerConnectionUpdate(
-      pc_handler, "updateIce", servers_string + ", " + constraints);
+      pc_handler,
+      "updateIce",
+      servers_string + ", " + transport_type + ", " + constraints);
 }
 
 void PeerConnectionTracker::TrackAddIceCandidate(
       RTCPeerConnectionHandler* pc_handler,
       const blink::WebRTCICECandidate& candidate,
       Source source) {
   string value = "mid: " + base::UTF16ToUTF8(candidate.sdpMid()) + ", " +
                  "candidate: " + base::UTF16ToUTF8(candidate.candidate());
   SendPeerConnectionUpdate(
       pc_handler,
@@ skipping 120 matching lines @@
     const std::string& value) {
   if (peer_connection_id_map_.find(pc_handler) == peer_connection_id_map_.end())
     return;
 
   RenderThreadImpl::current()->Send(
       new PeerConnectionTrackerHost_UpdatePeerConnection(
           peer_connection_id_map_[pc_handler], type, value));
 }
 
 }  // namespace content