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(observer, NULL);
 249   }
 250 }
 251
 252 void PeerConnectionTracker::RegisterPeerConnection(
 253     RTCPeerConnectionHandler* pc_handler,
 254     const std::vector<webrtc::PeerConnectionInterface::IceServer>& servers,
 255     const RTCMediaConstraints& constraints,
 256     const blink::WebFrame* frame) {
 257   DVLOG(1) << "PeerConnectionTracker::RegisterPeerConnection()";
 258   PeerConnectionInfo info;
 259
 260   info.lid = GetNextLocalID();
 261   info.servers = SerializeServers(servers);
 262   info.constraints = SerializeMediaConstraints(constraints);
 263   info.url = frame->document().url().spec();
 264   RenderThreadImpl::current()->Send(
 265       new PeerConnectionTrackerHost_AddPeerConnection(info));
 266
 267   DCHECK(peer_connection_id_map_.find(pc_handler) ==
 268          peer_connection_id_map_.end());
 269   peer_connection_id_map_[pc_handler] = info.lid;
 270 }
 271
 272 void PeerConnectionTracker::UnregisterPeerConnection(
 273     RTCPeerConnectionHandler* pc_handler) {
 274   DVLOG(1) << "PeerConnectionTracker::UnregisterPeerConnection()";
 275
 276   std::map<RTCPeerConnectionHandler*, int>::iterator it =
 277       peer_connection_id_map_.find(pc_handler);
 278
 279   if (it == peer_connection_id_map_.end()) {
 280     // The PeerConnection might not have been registered if its initilization
 281     // failed.
 282     return;
 283   }
 284
 285   RenderThreadImpl::current()->Send(
 286       new PeerConnectionTrackerHost_RemovePeerConnection(it->second));
 287
 288   peer_connection_id_map_.erase(it);
 289 }
 290
 291 void PeerConnectionTracker::TrackCreateOffer(
 292     RTCPeerConnectionHandler* pc_handler,
 293     const RTCMediaConstraints& constraints) {
 294   SendPeerConnectionUpdate(
 295       pc_handler, "createOffer",
 296       "constraints: {" + SerializeMediaConstraints(constraints) + "}");
 297 }
 298
 299 void PeerConnectionTracker::TrackCreateAnswer(
 300     RTCPeerConnectionHandler* pc_handler,
 301     const RTCMediaConstraints& constraints) {
 302   SendPeerConnectionUpdate(
 303       pc_handler, "createAnswer",
 304       "constraints: {" + SerializeMediaConstraints(constraints) + "}");
 305 }
 306
 307 void PeerConnectionTracker::TrackSetSessionDescription(
 308     RTCPeerConnectionHandler* pc_handler,
 309     const blink::WebRTCSessionDescription& desc,
 310     Source source) {
 311   string sdp = base::UTF16ToUTF8(desc.sdp());
 312   string type = base::UTF16ToUTF8(desc.type());
 313
 314   string value = "type: " + type + ", sdp: " + sdp;
 315   SendPeerConnectionUpdate(
 316       pc_handler,
 317       source == SOURCE_LOCAL ? "setLocalDescription" : "setRemoteDescription",
 318       value);
 319 }
 320
 321 void PeerConnectionTracker::TrackUpdateIce(
 322       RTCPeerConnectionHandler* pc_handler,
 323       const std::vector<webrtc::PeerConnectionInterface::IceServer>& servers,
 324       const RTCMediaConstraints& options) {
 325   string servers_string = "servers: " + SerializeServers(servers);
 326   string constraints =
 327       "constraints: {" + SerializeMediaConstraints(options) + "}";
 328
 329   SendPeerConnectionUpdate(
 330       pc_handler, "updateIce", servers_string + ", " + constraints);
 331 }
 332
 333 void PeerConnectionTracker::TrackAddIceCandidate(
 334       RTCPeerConnectionHandler* pc_handler,
 335       const blink::WebRTCICECandidate& candidate,
 336       Source source) {
 337   string value = "mid: " + base::UTF16ToUTF8(candidate.sdpMid()) + ", " +
 338                  "candidate: " + base::UTF16ToUTF8(candidate.candidate());
 339   SendPeerConnectionUpdate(
 340       pc_handler,
 341       source == SOURCE_LOCAL ? "onIceCandidate" : "addIceCandidate", value);
 342 }
 343
 344 void PeerConnectionTracker::TrackAddStream(
 345     RTCPeerConnectionHandler* pc_handler,
 346     const blink::WebMediaStream& stream,
 347     Source source){
 348   SendPeerConnectionUpdate(
 349       pc_handler, source == SOURCE_LOCAL ? "addStream" : "onAddStream",
 350       SerializeMediaDescriptor(stream));
 351 }
 352
 353 void PeerConnectionTracker::TrackRemoveStream(
 354     RTCPeerConnectionHandler* pc_handler,
 355     const blink::WebMediaStream& stream,
 356     Source source){
 357   SendPeerConnectionUpdate(
 358       pc_handler, source == SOURCE_LOCAL ? "removeStream" : "onRemoveStream",
 359       SerializeMediaDescriptor(stream));
 360 }
 361
 362 void PeerConnectionTracker::TrackCreateDataChannel(
 363     RTCPeerConnectionHandler* pc_handler,
 364     const webrtc::DataChannelInterface* data_channel,
 365     Source source) {
 366   string value = "label: " + data_channel->label() +
 367                  ", reliable: " + (data_channel->reliable() ? "true" : "false");
 368   SendPeerConnectionUpdate(
 369       pc_handler,
 370       source == SOURCE_LOCAL ? "createLocalDataChannel" : "onRemoteDataChannel",
 371       value);
 372 }
 373
 374 void PeerConnectionTracker::TrackStop(RTCPeerConnectionHandler* pc_handler) {
 375   SendPeerConnectionUpdate(pc_handler, "stop", std::string());
 376 }
 377
 378 void PeerConnectionTracker::TrackSignalingStateChange(
 379       RTCPeerConnectionHandler* pc_handler,
 380       WebRTCPeerConnectionHandlerClient::SignalingState state) {
 381   SendPeerConnectionUpdate(
 382       pc_handler, "signalingStateChange", GetSignalingStateString(state));
 383 }
 384
 385 void PeerConnectionTracker::TrackIceConnectionStateChange(
 386       RTCPeerConnectionHandler* pc_handler,
 387       WebRTCPeerConnectionHandlerClient::ICEConnectionState state) {
 388   SendPeerConnectionUpdate(
 389       pc_handler, "iceConnectionStateChange",
 390       GetIceConnectionStateString(state));
 391 }
 392
 393 void PeerConnectionTracker::TrackIceGatheringStateChange(
 394       RTCPeerConnectionHandler* pc_handler,
 395       WebRTCPeerConnectionHandlerClient::ICEGatheringState state) {
 396   SendPeerConnectionUpdate(
 397       pc_handler, "iceGatheringStateChange",
 398       GetIceGatheringStateString(state));
 399 }
 400
 401 void PeerConnectionTracker::TrackSessionDescriptionCallback(
 402     RTCPeerConnectionHandler* pc_handler, Action action,
 403     const string& callback_type, const string& value) {
 404   string update_type;
 405   switch (action) {
 406     case ACTION_SET_LOCAL_DESCRIPTION:
 407       update_type = "setLocalDescription";
 408       break;
 409     case ACTION_SET_REMOTE_DESCRIPTION:
 410       update_type = "setRemoteDescription";
 411       break;
 412     case ACTION_CREATE_OFFER:
 413       update_type = "createOffer";
 414       break;
 415     case ACTION_CREATE_ANSWER:
 416       update_type = "createAnswer";
 417       break;
 418     default:
 419       NOTREACHED();
 420       break;
 421   }
 422   update_type += callback_type;
 423
 424   SendPeerConnectionUpdate(pc_handler, update_type, value);
 425 }
 426
 427 void PeerConnectionTracker::TrackOnRenegotiationNeeded(
 428     RTCPeerConnectionHandler* pc_handler) {
 429   SendPeerConnectionUpdate(pc_handler, "onRenegotiationNeeded", std::string());
 430 }
 431
 432 void PeerConnectionTracker::TrackCreateDTMFSender(
 433     RTCPeerConnectionHandler* pc_handler,
 434     const blink::WebMediaStreamTrack& track) {
 435   SendPeerConnectionUpdate(pc_handler, "createDTMFSender",
 436                            base::UTF16ToUTF8(track.id()));
 437 }
 438
 439 void PeerConnectionTracker::TrackGetUserMedia(
 440     const blink::WebUserMediaRequest& user_media_request) {
 441   RTCMediaConstraints audio_constraints(user_media_request.audioConstraints());
 442   RTCMediaConstraints video_constraints(user_media_request.videoConstraints());
 443
 444   RenderThreadImpl::current()->Send(new PeerConnectionTrackerHost_GetUserMedia(
 445       user_media_request.securityOrigin().toString().utf8(),
 446       user_media_request.audio(),
 447       user_media_request.video(),
 448       SerializeMediaConstraints(audio_constraints),
 449       SerializeMediaConstraints(video_constraints)));
 450 }
 451
 452 int PeerConnectionTracker::GetNextLocalID() {
 453   return next_lid_++;
 454 }
 455
 456 void PeerConnectionTracker::SendPeerConnectionUpdate(
 457     RTCPeerConnectionHandler* pc_handler,
 458     const std::string& type,
 459     const std::string& value) {
 460   if (peer_connection_id_map_.find(pc_handler) == peer_connection_id_map_.end())
 461     return;
 462
 463   RenderThreadImpl::current()->Send(
 464       new PeerConnectionTrackerHost_UpdatePeerConnection(
 465           peer_connection_id_map_[pc_handler], type, value));
 466 }
 467
 468 }  // namespace content