src/content/renderer/media/peer_connection_tracker.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 #include "content/renderer/media/peer_connection_tracker.h"
   5
   6 #include "base/strings/utf_string_conversions.h"
   7 #include "content/common/media/peer_connection_tracker_messages.h"
   8 #include "content/renderer/media/rtc_media_constraints.h"
   9 #include "content/renderer/media/rtc_peer_connection_handler.h"
  10 #include "content/renderer/render_thread_impl.h"
  11 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
  12 #include "third_party/WebKit/public/platform/WebMediaStream.h"
  13 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
  14 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
  15 #include "third_party/WebKit/public/platform/WebRTCICECandidate.h"
  16 #include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandlerClient.h"
  17 #include "third_party/WebKit/public/web/WebDocument.h"
  18 #include "third_party/WebKit/public/web/WebFrame.h"
  19 #include "third_party/WebKit/public/web/WebUserMediaRequest.h"
  20
  21 using std::string;
  22 using webrtc::MediaConstraintsInterface;
  23 using blink::WebRTCPeerConnectionHandlerClient;
  24
  25 namespace content {
  26
  27 static string SerializeServers(
  28     const std::vector<webrtc::PeerConnectionInterface::IceServer>& servers) {
  29   string result = "[";
  30   for (size_t i = 0; i < servers.size(); ++i) {
  31     result += servers[i].uri;
  32     if (i != servers.size() - 1)
  33       result += ", ";
  34   }
  35   result += "]";
  36   return result;
  37 }
  38
  39 static string SerializeMediaConstraints(
  40     const RTCMediaConstraints& constraints) {
  41   string result;
  42   MediaConstraintsInterface::Constraints mandatory = constraints.GetMandatory();
  43   if (!mandatory.empty()) {
  44     result += "mandatory: {";
  45     for (size_t i = 0; i < mandatory.size(); ++i) {
  46       result += mandatory[i].key + ":" + mandatory[i].value;
  47       if (i != mandatory.size() - 1)
  48         result += ", ";
  49     }
  50     result += "}";
  51   }
  52   MediaConstraintsInterface::Constraints optional = constraints.GetOptional();
  53   if (!optional.empty()) {
  54     if (!result.empty())
  55       result += ", ";
  56     result += "optional: {";
  57     for (size_t i = 0; i < optional.size(); ++i) {
  58       result += optional[i].key + ":" + optional[i].value;
  59       if (i != optional.size() - 1)
  60         result += ", ";
  61     }
  62     result += "}";
  63   }
  64   return result;
  65 }
  66
  67 static string SerializeMediaStreamComponent(
  68     const blink::WebMediaStreamTrack component) {
  69   string id = base::UTF16ToUTF8(component.source().id());
  70   return id;
  71 }
  72
  73 static string SerializeMediaDescriptor(
  74     const blink::WebMediaStream& stream) {
  75   string label = base::UTF16ToUTF8(stream.id());
  76   string result = "label: " + label;
  77   blink::WebVector<blink::WebMediaStreamTrack> tracks;
  78   stream.audioTracks(tracks);
  79   if (!tracks.isEmpty()) {
  80     result += ", audio: [";
  81     for (size_t i = 0; i < tracks.size(); ++i) {
  82       result += SerializeMediaStreamComponent(tracks[i]);
  83       if (i != tracks.size() - 1)
  84         result += ", ";
  85     }
  86     result += "]";
  87   }
  88   stream.videoTracks(tracks);
  89   if (!tracks.isEmpty()) {
  90     result += ", video: [";
  91     for (size_t i = 0; i < tracks.size(); ++i) {
  92       result += SerializeMediaStreamComponent(tracks[i]);
  93       if (i != tracks.size() - 1)
  94         result += ", ";
  95     }
  96     result += "]";
  97   }
  98   return result;
  99 }
 100
 101 #define GET_STRING_OF_STATE(state)                \
 102   case WebRTCPeerConnectionHandlerClient::state:  \
 103     result = #state;                              \
 104     break;
 105
 106 static string GetSignalingStateString(
 107     WebRTCPeerConnectionHandlerClient::SignalingState state) {
 108   string result;
 109   switch (state) {
 110     GET_STRING_OF_STATE(SignalingStateStable)
 111     GET_STRING_OF_STATE(SignalingStateHaveLocalOffer)
 112     GET_STRING_OF_STATE(SignalingStateHaveRemoteOffer)
 113     GET_STRING_OF_STATE(SignalingStateHaveLocalPrAnswer)
 114     GET_STRING_OF_STATE(SignalingStateHaveRemotePrAnswer)
 115     GET_STRING_OF_STATE(SignalingStateClosed)
 116     default:
 117       NOTREACHED();
 118       break;
 119   }
 120   return result;
 121 }
 122
 123 static string GetIceConnectionStateString(
 124     WebRTCPeerConnectionHandlerClient::ICEConnectionState state) {
 125   string result;
 126   switch (state) {
 127     GET_STRING_OF_STATE(ICEConnectionStateStarting)
 128     GET_STRING_OF_STATE(ICEConnectionStateChecking)
 129     GET_STRING_OF_STATE(ICEConnectionStateConnected)
 130     GET_STRING_OF_STATE(ICEConnectionStateCompleted)
 131     GET_STRING_OF_STATE(ICEConnectionStateFailed)
 132     GET_STRING_OF_STATE(ICEConnectionStateDisconnected)
 133     GET_STRING_OF_STATE(ICEConnectionStateClosed)
 134     default:
 135       NOTREACHED();
 136       break;
 137   }
 138   return result;
 139 }
 140
 141 static string GetIceGatheringStateString(
 142     WebRTCPeerConnectionHandlerClient::ICEGatheringState state) {
 143   string result;
 144   switch (state) {
 145     GET_STRING_OF_STATE(ICEGatheringStateNew)
 146     GET_STRING_OF_STATE(ICEGatheringStateGathering)
 147     GET_STRING_OF_STATE(ICEGatheringStateComplete)
 148     default:
 149       NOTREACHED();
 150       break;
 151   }
 152   return result;
 153 }
 154
 155 // Builds a DictionaryValue from the StatsReport.
 156 // The caller takes the ownership of the returned value.
 157 // Note:
 158 // The format must be consistent with what webrtc_internals.js expects.
 159 // If you change it here, you must change webrtc_internals.js as well.
 160 static base::DictionaryValue* GetDictValueStats(
 161     const webrtc::StatsReport& report) {
 162   if (report.values.empty())
 163     return NULL;
 164
 165   base::DictionaryValue* dict = new base::DictionaryValue();
 166   dict->SetDouble("timestamp", report.timestamp);
 167
 168   base::ListValue* values = new base::ListValue();
 169   dict->Set("values", values);
 170
 171   for (size_t i = 0; i < report.values.size(); ++i) {
 172     values->AppendString(report.values[i].name);
 173     values->AppendString(report.values[i].value);
 174   }
 175   return dict;
 176 }
 177
 178 // Builds a DictionaryValue from the StatsReport.
 179 // The caller takes the ownership of the returned value.
 180 static base::DictionaryValue* GetDictValue(const webrtc::StatsReport& report) {
 181   scoped_ptr<base::DictionaryValue> stats, result;
 182
 183   stats.reset(GetDictValueStats(report));
 184   if (!stats)
 185     return NULL;
 186
 187   result.reset(new base::DictionaryValue());
 188   // Note:
 189   // The format must be consistent with what webrtc_internals.js expects.
 190   // If you change it here, you must change webrtc_internals.js as well.
 191   result->Set("stats", stats.release());
 192   result->SetString("id", report.id);
 193   result->SetString("type", report.type);
 194
 195   return result.release();
 196 }
 197
 198 class InternalStatsObserver : public webrtc::StatsObserver {
 199  public:
 200   InternalStatsObserver(int lid)
 201       : lid_(lid){}
 202
 203   virtual void OnComplete(
 204       const std::vector<webrtc::StatsReport>& reports) OVERRIDE {
 205     base::ListValue list;
 206
 207     for (size_t i = 0; i < reports.size(); ++i) {
 208       base::DictionaryValue* report = GetDictValue(reports[i]);
 209       if (report)
 210         list.Append(report);
 211     }
 212
 213     if (!list.empty())
 214       RenderThreadImpl::current()->Send(
 215           new PeerConnectionTrackerHost_AddStats(lid_, list));
 216   }
 217
 218  protected:
 219   virtual ~InternalStatsObserver() {}
 220
 221  private:
 222   int lid_;
 223 };
 224
 225 PeerConnectionTracker::PeerConnectionTracker() : next_lid_(1) {
 226 }
 227
 228 PeerConnectionTracker::~PeerConnectionTracker() {
 229 }
 230
 231 bool PeerConnectionTracker::OnControlMessageReceived(
 232     const IPC::Message& message) {
 233   bool handled = true;
 234   IPC_BEGIN_MESSAGE_MAP(PeerConnectionTracker, message)
 235     IPC_MESSAGE_HANDLER(PeerConnectionTracker_GetAllStats, OnGetAllStats)
 236     IPC_MESSAGE_UNHANDLED(handled = false)
 237   IPC_END_MESSAGE_MAP()
 238   return handled;
 239 }
 240
 241 void PeerConnectionTracker::OnGetAllStats() {
 242   for (PeerConnectionIdMap::iterator it = peer_connection_id_map_.begin();
 243        it != peer_connection_id_map_.end(); ++it) {
 244
 245     talk_base::scoped_refptr<InternalStatsObserver> observer(
 246         new talk_base::RefCountedObject<InternalStatsObserver>(it->second));
 247
 248     it->first->GetStats(
 249         observer,
 250         NULL,
 251         webrtc::PeerConnectionInterface::kStatsOutputLevelDebug);
 252   }
 253 }
 254
 255 void PeerConnectionTracker::RegisterPeerConnection(
 256     RTCPeerConnectionHandler* pc_handler,
 257     const std::vector<webrtc::PeerConnectionInterface::IceServer>& servers,
 258     const RTCMediaConstraints& constraints,
 259     const blink::WebFrame* frame) {
 260   DVLOG(1) << "PeerConnectionTracker::RegisterPeerConnection()";
 261   PeerConnectionInfo info;
 262
 263   info.lid = GetNextLocalID();
 264   info.servers = SerializeServers(servers);
 265   info.constraints = SerializeMediaConstraints(constraints);
 266   info.url = frame->document().url().spec();
 267   RenderThreadImpl::current()->Send(
 268       new PeerConnectionTrackerHost_AddPeerConnection(info));
 269
 270   DCHECK(peer_connection_id_map_.find(pc_handler) ==
 271          peer_connection_id_map_.end());
 272   peer_connection_id_map_[pc_handler] = info.lid;
 273 }
 274
 275 void PeerConnectionTracker::UnregisterPeerConnection(
 276     RTCPeerConnectionHandler* pc_handler) {
 277   DVLOG(1) << "PeerConnectionTracker::UnregisterPeerConnection()";
 278
 279   std::map<RTCPeerConnectionHandler*, int>::iterator it =
 280       peer_connection_id_map_.find(pc_handler);
 281
 282   if (it == peer_connection_id_map_.end()) {
 283     // The PeerConnection might not have been registered if its initilization
 284     // failed.
 285     return;
 286   }
 287
 288   RenderThreadImpl::current()->Send(
 289       new PeerConnectionTrackerHost_RemovePeerConnection(it->second));
 290
 291   peer_connection_id_map_.erase(it);
 292 }
 293
 294 void PeerConnectionTracker::TrackCreateOffer(
 295     RTCPeerConnectionHandler* pc_handler,
 296     const RTCMediaConstraints& constraints) {
 297   SendPeerConnectionUpdate(
 298       pc_handler, "createOffer",
 299       "constraints: {" + SerializeMediaConstraints(constraints) + "}");
 300 }
 301
 302 void PeerConnectionTracker::TrackCreateAnswer(
 303     RTCPeerConnectionHandler* pc_handler,
 304     const RTCMediaConstraints& constraints) {
 305   SendPeerConnectionUpdate(
 306       pc_handler, "createAnswer",
 307       "constraints: {" + SerializeMediaConstraints(constraints) + "}");
 308 }
 309
 310 void PeerConnectionTracker::TrackSetSessionDescription(
 311     RTCPeerConnectionHandler* pc_handler,
 312     const blink::WebRTCSessionDescription& desc,
 313     Source source) {
 314   string sdp = base::UTF16ToUTF8(desc.sdp());
 315   string type = base::UTF16ToUTF8(desc.type());
 316
 317   string value = "type: " + type + ", sdp: " + sdp;
 318   SendPeerConnectionUpdate(
 319       pc_handler,
 320       source == SOURCE_LOCAL ? "setLocalDescription" : "setRemoteDescription",
 321       value);
 322 }
 323
 324 void PeerConnectionTracker::TrackUpdateIce(
 325       RTCPeerConnectionHandler* pc_handler,
 326       const std::vector<webrtc::PeerConnectionInterface::IceServer>& servers,
 327       const RTCMediaConstraints& options) {
 328   string servers_string = "servers: " + SerializeServers(servers);
 329   string constraints =
 330       "constraints: {" + SerializeMediaConstraints(options) + "}";
 331
 332   SendPeerConnectionUpdate(
 333       pc_handler, "updateIce", servers_string + ", " + constraints);
 334 }
 335
 336 void PeerConnectionTracker::TrackAddIceCandidate(
 337       RTCPeerConnectionHandler* pc_handler,
 338       const blink::WebRTCICECandidate& candidate,
 339       Source source) {
 340   string value = "mid: " + base::UTF16ToUTF8(candidate.sdpMid()) + ", " +
 341                  "candidate: " + base::UTF16ToUTF8(candidate.candidate());
 342   SendPeerConnectionUpdate(
 343       pc_handler,
 344       source == SOURCE_LOCAL ? "onIceCandidate" : "addIceCandidate", value);
 345 }
 346
 347 void PeerConnectionTracker::TrackAddStream(
 348     RTCPeerConnectionHandler* pc_handler,
 349     const blink::WebMediaStream& stream,
 350     Source source){
 351   SendPeerConnectionUpdate(
 352       pc_handler, source == SOURCE_LOCAL ? "addStream" : "onAddStream",
 353       SerializeMediaDescriptor(stream));
 354 }
 355
 356 void PeerConnectionTracker::TrackRemoveStream(
 357     RTCPeerConnectionHandler* pc_handler,
 358     const blink::WebMediaStream& stream,
 359     Source source){
 360   SendPeerConnectionUpdate(
 361       pc_handler, source == SOURCE_LOCAL ? "removeStream" : "onRemoveStream",
 362       SerializeMediaDescriptor(stream));
 363 }
 364
 365 void PeerConnectionTracker::TrackCreateDataChannel(
 366     RTCPeerConnectionHandler* pc_handler,
 367     const webrtc::DataChannelInterface* data_channel,
 368     Source source) {
 369   string value = "label: " + data_channel->label() +
 370                  ", reliable: " + (data_channel->reliable() ? "true" : "false");
 371   SendPeerConnectionUpdate(
 372       pc_handler,
 373       source == SOURCE_LOCAL ? "createLocalDataChannel" : "onRemoteDataChannel",
 374       value);
 375 }
 376
 377 void PeerConnectionTracker::TrackStop(RTCPeerConnectionHandler* pc_handler) {
 378   SendPeerConnectionUpdate(pc_handler, "stop", std::string());
 379 }
 380
 381 void PeerConnectionTracker::TrackSignalingStateChange(
 382       RTCPeerConnectionHandler* pc_handler,
 383       WebRTCPeerConnectionHandlerClient::SignalingState state) {
 384   SendPeerConnectionUpdate(
 385       pc_handler, "signalingStateChange", GetSignalingStateString(state));
 386 }
 387
 388 void PeerConnectionTracker::TrackIceConnectionStateChange(
 389       RTCPeerConnectionHandler* pc_handler,
 390       WebRTCPeerConnectionHandlerClient::ICEConnectionState state) {
 391   SendPeerConnectionUpdate(
 392       pc_handler, "iceConnectionStateChange",
 393       GetIceConnectionStateString(state));
 394 }
 395
 396 void PeerConnectionTracker::TrackIceGatheringStateChange(
 397       RTCPeerConnectionHandler* pc_handler,
 398       WebRTCPeerConnectionHandlerClient::ICEGatheringState state) {
 399   SendPeerConnectionUpdate(
 400       pc_handler, "iceGatheringStateChange",
 401       GetIceGatheringStateString(state));
 402 }
 403
 404 void PeerConnectionTracker::TrackSessionDescriptionCallback(
 405     RTCPeerConnectionHandler* pc_handler, Action action,
 406     const string& callback_type, const string& value) {
 407   string update_type;
 408   switch (action) {
 409     case ACTION_SET_LOCAL_DESCRIPTION:
 410       update_type = "setLocalDescription";
 411       break;
 412     case ACTION_SET_REMOTE_DESCRIPTION:
 413       update_type = "setRemoteDescription";
 414       break;
 415     case ACTION_CREATE_OFFER:
 416       update_type = "createOffer";
 417       break;
 418     case ACTION_CREATE_ANSWER:
 419       update_type = "createAnswer";
 420       break;
 421     default:
 422       NOTREACHED();
 423       break;
 424   }
 425   update_type += callback_type;
 426
 427   SendPeerConnectionUpdate(pc_handler, update_type, value);
 428 }
 429
 430 void PeerConnectionTracker::TrackOnRenegotiationNeeded(
 431     RTCPeerConnectionHandler* pc_handler) {
 432   SendPeerConnectionUpdate(pc_handler, "onRenegotiationNeeded", std::string());
 433 }
 434
 435 void PeerConnectionTracker::TrackCreateDTMFSender(
 436     RTCPeerConnectionHandler* pc_handler,
 437     const blink::WebMediaStreamTrack& track) {
 438   SendPeerConnectionUpdate(pc_handler, "createDTMFSender",
 439                            base::UTF16ToUTF8(track.id()));
 440 }
 441
 442 void PeerConnectionTracker::TrackGetUserMedia(
 443     const blink::WebUserMediaRequest& user_media_request) {
 444   RTCMediaConstraints audio_constraints(user_media_request.audioConstraints());
 445   RTCMediaConstraints video_constraints(user_media_request.videoConstraints());
 446
 447   RenderThreadImpl::current()->Send(new PeerConnectionTrackerHost_GetUserMedia(
 448       user_media_request.securityOrigin().toString().utf8(),
 449       user_media_request.audio(),
 450       user_media_request.video(),
 451       SerializeMediaConstraints(audio_constraints),
 452       SerializeMediaConstraints(video_constraints)));
 453 }
 454
 455 int PeerConnectionTracker::GetNextLocalID() {
 456   return next_lid_++;
 457 }
 458
 459 void PeerConnectionTracker::SendPeerConnectionUpdate(
 460     RTCPeerConnectionHandler* pc_handler,
 461     const std::string& type,
 462     const std::string& value) {
 463   if (peer_connection_id_map_.find(pc_handler) == peer_connection_id_map_.end())
 464     return;
 465
 466   RenderThreadImpl::current()->Send(
 467       new PeerConnectionTrackerHost_UpdatePeerConnection(
 468           peer_connection_id_map_[pc_handler], type, value));
 469 }
 470
 471 }  // namespace content