Adds the UserMedia requests to the UI of chrome://webrtc-internals.

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 18 matching lines @@
   string result = "[";
   for (size_t i = 0; i < servers.size(); ++i) {
     result += servers[i].uri;
     if (i != servers.size() - 1)
       result += ", ";
   }
   result += "]";
   return result;
 }
 
+static RTCMediaConstraints GetNativeMediaConstraints(
+    const blink::WebMediaConstraints& constraints) {
+  RTCMediaConstraints native_constraints;
+
+  blink::WebVector<blink::WebMediaConstraint> mandatory;
+  constraints.getMandatoryConstraints(mandatory);
+  for (size_t i = 0; i < mandatory.size(); ++i) {
+    native_constraints.AddMandatory(
+        mandatory[i].m_name.utf8(), mandatory[i].m_value.utf8(), false);
+  }
+
+  blink::WebVector<blink::WebMediaConstraint> optional;
+  constraints.getOptionalConstraints(optional);
+  for (size_t i = 0; i < optional.size(); ++i) {
+    native_constraints.AddOptional(
+        optional[i].m_name.utf8(), optional[i].m_value.utf8(), false);
+  }
+  return native_constraints;
+}
+
 static string SerializeMediaConstraints(
     const RTCMediaConstraints& constraints) {
   string result;
   MediaConstraintsInterface::Constraints mandatory = constraints.GetMandatory();
   if (!mandatory.empty()) {
     result += "mandatory: {";
     for (size_t i = 0; i < mandatory.size(); ++i) {
       result += mandatory[i].key + ":" + mandatory[i].value;
       if (i != mandatory.size() - 1)
         result += ", ";
@@ skipping 385 matching lines @@
 
 void PeerConnectionTracker::TrackCreateDTMFSender(
     RTCPeerConnectionHandler* pc_handler,
     const blink::WebMediaStreamTrack& track) {
   SendPeerConnectionUpdate(pc_handler, "createDTMFSender",
                            base::UTF16ToUTF8(track.id()));
 }
 
 void PeerConnectionTracker::TrackGetUserMedia(
     const blink::WebUserMediaRequest& user_media_request) {
-  RTCMediaConstraints audio_constraints(user_media_request.audioConstraints());
-  RTCMediaConstraints video_constraints(user_media_request.videoConstraints());
+  RTCMediaConstraints audio_constraints(
+      GetNativeMediaConstraints(user_media_request.audioConstraints()));
+  RTCMediaConstraints video_constraints(
+      GetNativeMediaConstraints(user_media_request.videoConstraints()));
 
   RenderThreadImpl::current()->Send(new PeerConnectionTrackerHost_GetUserMedia(
       user_media_request.securityOrigin().toString().utf8(),
       user_media_request.audio(),
       user_media_request.video(),
       SerializeMediaConstraints(audio_constraints),
       SerializeMediaConstraints(video_constraints)));
 }
 
 int PeerConnectionTracker::GetNextLocalID() {
   return next_lid_++;
 }
 
 void PeerConnectionTracker::SendPeerConnectionUpdate(
     RTCPeerConnectionHandler* pc_handler,
     const std::string& type,
     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