content/renderer/media/rtc_peer_connection_handler.cc

   1 // Copyright (c) 2012 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
   5 #include "content/renderer/media/rtc_peer_connection_handler.h"
   6
   7 #include <string>
   8 #include <utility>
   9 #include <vector>
  10
  11 #include "base/command_line.h"
  12 #include "base/debug/trace_event.h"
  13 #include "base/lazy_instance.h"
  14 #include "base/logging.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/metrics/histogram.h"
  17 #include "base/stl_util.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "content/public/common/content_switches.h"
  20 #include "content/renderer/media/media_stream_track.h"
  21 #include "content/renderer/media/peer_connection_tracker.h"
  22 #include "content/renderer/media/remote_media_stream_impl.h"
  23 #include "content/renderer/media/rtc_data_channel_handler.h"
  24 #include "content/renderer/media/rtc_dtmf_sender_handler.h"
  25 #include "content/renderer/media/rtc_media_constraints.h"
  26 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
  27 #include "content/renderer/media/webrtc/webrtc_media_stream_adapter.h"
  28 #include "content/renderer/media/webrtc_audio_capturer.h"
  29 #include "content/renderer/media/webrtc_audio_device_impl.h"
  30 #include "content/renderer/media/webrtc_uma_histograms.h"
  31 #include "content/renderer/render_thread_impl.h"
  32 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
  33 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
  34 #include "third_party/WebKit/public/platform/WebRTCConfiguration.h"
  35 #include "third_party/WebKit/public/platform/WebRTCDataChannelInit.h"
  36 #include "third_party/WebKit/public/platform/WebRTCICECandidate.h"
  37 #include "third_party/WebKit/public/platform/WebRTCSessionDescription.h"
  38 #include "third_party/WebKit/public/platform/WebRTCSessionDescriptionRequest.h"
  39 #include "third_party/WebKit/public/platform/WebRTCVoidRequest.h"
  40 #include "third_party/WebKit/public/platform/WebURL.h"
  41
  42 namespace content {
  43
  44 // Converter functions from libjingle types to WebKit types.
  45 blink::WebRTCPeerConnectionHandlerClient::ICEGatheringState
  46 GetWebKitIceGatheringState(
  47     webrtc::PeerConnectionInterface::IceGatheringState state) {
  48   using blink::WebRTCPeerConnectionHandlerClient;
  49   switch (state) {
  50     case webrtc::PeerConnectionInterface::kIceGatheringNew:
  51       return WebRTCPeerConnectionHandlerClient::ICEGatheringStateNew;
  52     case webrtc::PeerConnectionInterface::kIceGatheringGathering:
  53       return WebRTCPeerConnectionHandlerClient::ICEGatheringStateGathering;
  54     case webrtc::PeerConnectionInterface::kIceGatheringComplete:
  55       return WebRTCPeerConnectionHandlerClient::ICEGatheringStateComplete;
  56     default:
  57       NOTREACHED();
  58       return WebRTCPeerConnectionHandlerClient::ICEGatheringStateNew;
  59   }
  60 }
  61
  62 static blink::WebRTCPeerConnectionHandlerClient::ICEConnectionState
  63 GetWebKitIceConnectionState(
  64     webrtc::PeerConnectionInterface::IceConnectionState ice_state) {
  65   using blink::WebRTCPeerConnectionHandlerClient;
  66   switch (ice_state) {
  67     case webrtc::PeerConnectionInterface::kIceConnectionNew:
  68       return WebRTCPeerConnectionHandlerClient::ICEConnectionStateStarting;
  69     case webrtc::PeerConnectionInterface::kIceConnectionChecking:
  70       return WebRTCPeerConnectionHandlerClient::ICEConnectionStateChecking;
  71     case webrtc::PeerConnectionInterface::kIceConnectionConnected:
  72       return WebRTCPeerConnectionHandlerClient::ICEConnectionStateConnected;
  73     case webrtc::PeerConnectionInterface::kIceConnectionCompleted:
  74       return WebRTCPeerConnectionHandlerClient::ICEConnectionStateCompleted;
  75     case webrtc::PeerConnectionInterface::kIceConnectionFailed:
  76       return WebRTCPeerConnectionHandlerClient::ICEConnectionStateFailed;
  77     case webrtc::PeerConnectionInterface::kIceConnectionDisconnected:
  78       return WebRTCPeerConnectionHandlerClient::ICEConnectionStateDisconnected;
  79     case webrtc::PeerConnectionInterface::kIceConnectionClosed:
  80       return WebRTCPeerConnectionHandlerClient::ICEConnectionStateClosed;
  81     default:
  82       NOTREACHED();
  83       return WebRTCPeerConnectionHandlerClient::ICEConnectionStateClosed;
  84   }
  85 }
  86
  87 static blink::WebRTCPeerConnectionHandlerClient::SignalingState
  88 GetWebKitSignalingState(webrtc::PeerConnectionInterface::SignalingState state) {
  89   using blink::WebRTCPeerConnectionHandlerClient;
  90   switch (state) {
  91     case webrtc::PeerConnectionInterface::kStable:
  92       return WebRTCPeerConnectionHandlerClient::SignalingStateStable;
  93     case webrtc::PeerConnectionInterface::kHaveLocalOffer:
  94       return WebRTCPeerConnectionHandlerClient::SignalingStateHaveLocalOffer;
  95     case webrtc::PeerConnectionInterface::kHaveLocalPrAnswer:
  96       return WebRTCPeerConnectionHandlerClient::SignalingStateHaveLocalPrAnswer;
  97     case webrtc::PeerConnectionInterface::kHaveRemoteOffer:
  98       return WebRTCPeerConnectionHandlerClient::SignalingStateHaveRemoteOffer;
  99     case webrtc::PeerConnectionInterface::kHaveRemotePrAnswer:
 100       return
 101           WebRTCPeerConnectionHandlerClient::SignalingStateHaveRemotePrAnswer;
 102     case webrtc::PeerConnectionInterface::kClosed:
 103       return WebRTCPeerConnectionHandlerClient::SignalingStateClosed;
 104     default:
 105       NOTREACHED();
 106       return WebRTCPeerConnectionHandlerClient::SignalingStateClosed;
 107   }
 108 }
 109
 110 static blink::WebRTCSessionDescription
 111 CreateWebKitSessionDescription(
 112     const webrtc::SessionDescriptionInterface* native_desc) {
 113   blink::WebRTCSessionDescription description;
 114   if (!native_desc) {
 115     LOG(ERROR) << "Native session description is null.";
 116     return description;
 117   }
 118
 119   std::string sdp;
 120   if (!native_desc->ToString(&sdp)) {
 121     LOG(ERROR) << "Failed to get SDP string of native session description.";
 122     return description;
 123   }
 124
 125   description.initialize(base::UTF8ToUTF16(native_desc->type()),
 126                          base::UTF8ToUTF16(sdp));
 127   return description;
 128 }
 129
 130 // Converter functions from WebKit types to libjingle types.
 131
 132 static void GetNativeIceServers(
 133     const blink::WebRTCConfiguration& server_configuration,
 134     webrtc::PeerConnectionInterface::IceServers* servers) {
 135   if (server_configuration.isNull() || !servers)
 136     return;
 137   for (size_t i = 0; i < server_configuration.numberOfServers(); ++i) {
 138     webrtc::PeerConnectionInterface::IceServer server;
 139     const blink::WebRTCICEServer& webkit_server =
 140         server_configuration.server(i);
 141     server.username = base::UTF16ToUTF8(webkit_server.username());
 142     server.password = base::UTF16ToUTF8(webkit_server.credential());
 143     server.uri = webkit_server.uri().spec();
 144     servers->push_back(server);
 145   }
 146 }
 147
 148 class SessionDescriptionRequestTracker {
 149  public:
 150   SessionDescriptionRequestTracker(RTCPeerConnectionHandler* handler,
 151                                    PeerConnectionTracker::Action action)
 152       : handler_(handler), action_(action) {}
 153
 154   void TrackOnSuccess(const webrtc::SessionDescriptionInterface* desc) {
 155     std::string value;
 156     if (desc) {
 157       desc->ToString(&value);
 158       value = "type: " + desc->type() + ", sdp: " + value;
 159     }
 160     if (handler_->peer_connection_tracker())
 161       handler_->peer_connection_tracker()->TrackSessionDescriptionCallback(
 162           handler_, action_, "OnSuccess", value);
 163   }
 164
 165   void TrackOnFailure(const std::string& error) {
 166     if (handler_->peer_connection_tracker())
 167       handler_->peer_connection_tracker()->TrackSessionDescriptionCallback(
 168           handler_, action_, "OnFailure", error);
 169   }
 170
 171  private:
 172   RTCPeerConnectionHandler* handler_;
 173   PeerConnectionTracker::Action action_;
 174 };
 175
 176 // Class mapping responses from calls to libjingle CreateOffer/Answer and
 177 // the blink::WebRTCSessionDescriptionRequest.
 178 class CreateSessionDescriptionRequest
 179     : public webrtc::CreateSessionDescriptionObserver {
 180  public:
 181   explicit CreateSessionDescriptionRequest(
 182       const blink::WebRTCSessionDescriptionRequest& request,
 183       RTCPeerConnectionHandler* handler,
 184       PeerConnectionTracker::Action action)
 185       : webkit_request_(request), tracker_(handler, action) {}
 186
 187   virtual void OnSuccess(webrtc::SessionDescriptionInterface* desc) OVERRIDE {
 188     tracker_.TrackOnSuccess(desc);
 189     webkit_request_.requestSucceeded(CreateWebKitSessionDescription(desc));
 190     delete desc;
 191   }
 192   virtual void OnFailure(const std::string& error) OVERRIDE {
 193     tracker_.TrackOnFailure(error);
 194     webkit_request_.requestFailed(base::UTF8ToUTF16(error));
 195   }
 196
 197  protected:
 198   virtual ~CreateSessionDescriptionRequest() {}
 199
 200  private:
 201   blink::WebRTCSessionDescriptionRequest webkit_request_;
 202   SessionDescriptionRequestTracker tracker_;
 203 };
 204
 205 // Class mapping responses from calls to libjingle
 206 // SetLocalDescription/SetRemoteDescription and a blink::WebRTCVoidRequest.
 207 class SetSessionDescriptionRequest
 208     : public webrtc::SetSessionDescriptionObserver {
 209  public:
 210   explicit SetSessionDescriptionRequest(
 211       const blink::WebRTCVoidRequest& request,
 212       RTCPeerConnectionHandler* handler,
 213       PeerConnectionTracker::Action action)
 214       : webkit_request_(request), tracker_(handler, action) {}
 215
 216   virtual void OnSuccess() OVERRIDE {
 217     tracker_.TrackOnSuccess(NULL);
 218     webkit_request_.requestSucceeded();
 219   }
 220   virtual void OnFailure(const std::string& error) OVERRIDE {
 221     tracker_.TrackOnFailure(error);
 222     webkit_request_.requestFailed(base::UTF8ToUTF16(error));
 223   }
 224
 225  protected:
 226   virtual ~SetSessionDescriptionRequest() {}
 227
 228  private:
 229   blink::WebRTCVoidRequest webkit_request_;
 230   SessionDescriptionRequestTracker tracker_;
 231 };
 232
 233 // Class mapping responses from calls to libjingle
 234 // GetStats into a blink::WebRTCStatsCallback.
 235 class StatsResponse : public webrtc::StatsObserver {
 236  public:
 237   explicit StatsResponse(const scoped_refptr<LocalRTCStatsRequest>& request)
 238       : request_(request.get()), response_(request_->createResponse().get()) {
 239     // Measure the overall time it takes to satisfy a getStats request.
 240     TRACE_EVENT_ASYNC_BEGIN0("webrtc", "getStats_Native", this);
 241   }
 242
 243   virtual void OnComplete(
 244       const std::vector<webrtc::StatsReport>& reports) OVERRIDE {
 245     TRACE_EVENT0("webrtc", "StatsResponse::OnComplete")
 246     for (std::vector<webrtc::StatsReport>::const_iterator it = reports.begin();
 247          it != reports.end(); ++it) {
 248       if (it->values.size() > 0) {
 249         AddReport(*it);
 250       }
 251     }
 252
 253     // Record the getSync operation as done before calling into Blink so that
 254     // we don't skew the perf measurements of the native code with whatever the
 255     // callback might be doing.
 256     TRACE_EVENT_ASYNC_END0("webrtc", "getStats_Native", this);
 257
 258     request_->requestSucceeded(response_);
 259   }
 260
 261  private:
 262   void AddReport(const webrtc::StatsReport& report) {
 263     int idx = response_->addReport(blink::WebString::fromUTF8(report.id),
 264                                    blink::WebString::fromUTF8(report.type),
 265                                    report.timestamp);
 266     for (webrtc::StatsReport::Values::const_iterator value_it =
 267          report.values.begin();
 268          value_it != report.values.end(); ++value_it) {
 269       AddStatistic(idx, value_it->name, value_it->value);
 270     }
 271   }
 272
 273   void AddStatistic(int idx, const std::string& name,
 274                     const std::string& value) {
 275     response_->addStatistic(idx,
 276                             blink::WebString::fromUTF8(name),
 277                             blink::WebString::fromUTF8(value));
 278   }
 279
 280   talk_base::scoped_refptr<LocalRTCStatsRequest> request_;
 281   talk_base::scoped_refptr<LocalRTCStatsResponse> response_;
 282 };
 283
 284 // Implementation of LocalRTCStatsRequest.
 285 LocalRTCStatsRequest::LocalRTCStatsRequest(blink::WebRTCStatsRequest impl)
 286     : impl_(impl),
 287       response_(NULL) {
 288 }
 289
 290 LocalRTCStatsRequest::LocalRTCStatsRequest() {}
 291 LocalRTCStatsRequest::~LocalRTCStatsRequest() {}
 292
 293 bool LocalRTCStatsRequest::hasSelector() const {
 294   return impl_.hasSelector();
 295 }
 296
 297 blink::WebMediaStreamTrack LocalRTCStatsRequest::component() const {
 298   return impl_.component();
 299 }
 300
 301 scoped_refptr<LocalRTCStatsResponse> LocalRTCStatsRequest::createResponse() {
 302   DCHECK(!response_);
 303   response_ = new talk_base::RefCountedObject<LocalRTCStatsResponse>(
 304       impl_.createResponse());
 305   return response_.get();
 306 }
 307
 308 void LocalRTCStatsRequest::requestSucceeded(
 309     const LocalRTCStatsResponse* response) {
 310   impl_.requestSucceeded(response->webKitStatsResponse());
 311 }
 312
 313 // Implementation of LocalRTCStatsResponse.
 314 blink::WebRTCStatsResponse LocalRTCStatsResponse::webKitStatsResponse() const {
 315   return impl_;
 316 }
 317
 318 size_t LocalRTCStatsResponse::addReport(blink::WebString type,
 319                                         blink::WebString id,
 320                                         double timestamp) {
 321   return impl_.addReport(type, id, timestamp);
 322 }
 323
 324 void LocalRTCStatsResponse::addStatistic(size_t report,
 325                                          blink::WebString name,
 326                                          blink::WebString value) {
 327   impl_.addStatistic(report, name, value);
 328 }
 329
 330 namespace {
 331
 332 class PeerConnectionUMAObserver : public webrtc::UMAObserver {
 333  public:
 334   PeerConnectionUMAObserver() {}
 335   virtual ~PeerConnectionUMAObserver() {}
 336
 337   virtual void IncrementCounter(
 338       webrtc::PeerConnectionUMAMetricsCounter counter) OVERRIDE {
 339     UMA_HISTOGRAM_ENUMERATION("WebRTC.PeerConnection.IPMetrics",
 340                               counter,
 341                               webrtc::kBoundary);
 342   }
 343
 344   virtual void AddHistogramSample(
 345       webrtc::PeerConnectionUMAMetricsName type, int value) OVERRIDE {
 346     switch (type) {
 347       case webrtc::kTimeToConnect:
 348         UMA_HISTOGRAM_MEDIUM_TIMES(
 349             "WebRTC.PeerConnection.TimeToConnect",
 350             base::TimeDelta::FromMilliseconds(value));
 351         break;
 352       case webrtc::kNetworkInterfaces_IPv4:
 353         UMA_HISTOGRAM_COUNTS_100("WebRTC.PeerConnection.IPv4Interfaces",
 354                                  value);
 355         break;
 356       case webrtc::kNetworkInterfaces_IPv6:
 357         UMA_HISTOGRAM_COUNTS_100("WebRTC.PeerConnection.IPv6Interfaces",
 358                                  value);
 359         break;
 360       default:
 361         NOTREACHED();
 362     }
 363   }
 364 };
 365
 366 base::LazyInstance<std::set<RTCPeerConnectionHandler*> >::Leaky
 367     g_peer_connection_handlers = LAZY_INSTANCE_INITIALIZER;
 368
 369 }  // namespace
 370
 371 RTCPeerConnectionHandler::RTCPeerConnectionHandler(
 372     blink::WebRTCPeerConnectionHandlerClient* client,
 373     PeerConnectionDependencyFactory* dependency_factory)
 374     : client_(client),
 375       dependency_factory_(dependency_factory),
 376       frame_(NULL),
 377       peer_connection_tracker_(NULL),
 378       num_data_channels_created_(0) {
 379   g_peer_connection_handlers.Get().insert(this);
 380 }
 381
 382 RTCPeerConnectionHandler::~RTCPeerConnectionHandler() {
 383   g_peer_connection_handlers.Get().erase(this);
 384   if (peer_connection_tracker_)
 385     peer_connection_tracker_->UnregisterPeerConnection(this);
 386   STLDeleteValues(&remote_streams_);
 387
 388   UMA_HISTOGRAM_COUNTS_10000(
 389       "WebRTC.NumDataChannelsPerPeerConnection", num_data_channels_created_);
 390 }
 391
 392 // static
 393 void RTCPeerConnectionHandler::DestructAllHandlers() {
 394   std::set<RTCPeerConnectionHandler*> handlers(
 395       g_peer_connection_handlers.Get().begin(),
 396       g_peer_connection_handlers.Get().end());
 397   for (std::set<RTCPeerConnectionHandler*>::iterator handler = handlers.begin();
 398        handler != handlers.end();
 399        ++handler) {
 400     (*handler)->client_->releasePeerConnectionHandler();
 401   }
 402 }
 403
 404 void RTCPeerConnectionHandler::associateWithFrame(blink::WebFrame* frame) {
 405   DCHECK(frame);
 406   frame_ = frame;
 407 }
 408
 409 bool RTCPeerConnectionHandler::initialize(
 410     const blink::WebRTCConfiguration& server_configuration,
 411     const blink::WebMediaConstraints& options) {
 412   DCHECK(frame_);
 413
 414   peer_connection_tracker_ =
 415       RenderThreadImpl::current()->peer_connection_tracker();
 416
 417   webrtc::PeerConnectionInterface::IceServers servers;
 418   GetNativeIceServers(server_configuration, &servers);
 419
 420   RTCMediaConstraints constraints(options);
 421
 422   native_peer_connection_ =
 423       dependency_factory_->CreatePeerConnection(
 424           servers, &constraints, frame_, this);
 425   if (!native_peer_connection_.get()) {
 426     LOG(ERROR) << "Failed to initialize native PeerConnection.";
 427     return false;
 428   }
 429   if (peer_connection_tracker_)
 430     peer_connection_tracker_->RegisterPeerConnection(
 431         this, servers, constraints, frame_);
 432
 433   uma_observer_ = new talk_base::RefCountedObject<PeerConnectionUMAObserver>();
 434   native_peer_connection_->RegisterUMAObserver(uma_observer_.get());
 435   return true;
 436 }
 437
 438 bool RTCPeerConnectionHandler::InitializeForTest(
 439     const blink::WebRTCConfiguration& server_configuration,
 440     const blink::WebMediaConstraints& options,
 441     PeerConnectionTracker* peer_connection_tracker) {
 442   webrtc::PeerConnectionInterface::IceServers servers;
 443   GetNativeIceServers(server_configuration, &servers);
 444
 445   RTCMediaConstraints constraints(options);
 446   native_peer_connection_ =
 447       dependency_factory_->CreatePeerConnection(
 448           servers, &constraints, NULL, this);
 449   if (!native_peer_connection_.get()) {
 450     LOG(ERROR) << "Failed to initialize native PeerConnection.";
 451     return false;
 452   }
 453   peer_connection_tracker_ = peer_connection_tracker;
 454   return true;
 455 }
 456
 457 void RTCPeerConnectionHandler::createOffer(
 458     const blink::WebRTCSessionDescriptionRequest& request,
 459     const blink::WebMediaConstraints& options) {
 460   scoped_refptr<CreateSessionDescriptionRequest> description_request(
 461       new talk_base::RefCountedObject<CreateSessionDescriptionRequest>(
 462           request, this, PeerConnectionTracker::ACTION_CREATE_OFFER));
 463   RTCMediaConstraints constraints(options);
 464   native_peer_connection_->CreateOffer(description_request.get(), &constraints);
 465
 466   if (peer_connection_tracker_)
 467     peer_connection_tracker_->TrackCreateOffer(this, constraints);
 468 }
 469
 470 void RTCPeerConnectionHandler::createAnswer(
 471     const blink::WebRTCSessionDescriptionRequest& request,
 472     const blink::WebMediaConstraints& options) {
 473   scoped_refptr<CreateSessionDescriptionRequest> description_request(
 474       new talk_base::RefCountedObject<CreateSessionDescriptionRequest>(
 475           request, this, PeerConnectionTracker::ACTION_CREATE_ANSWER));
 476   RTCMediaConstraints constraints(options);
 477   native_peer_connection_->CreateAnswer(description_request.get(),
 478                                         &constraints);
 479
 480   if (peer_connection_tracker_)
 481     peer_connection_tracker_->TrackCreateAnswer(this, constraints);
 482 }
 483
 484 void RTCPeerConnectionHandler::setLocalDescription(
 485     const blink::WebRTCVoidRequest& request,
 486     const blink::WebRTCSessionDescription& description) {
 487   webrtc::SdpParseError error;
 488   webrtc::SessionDescriptionInterface* native_desc =
 489       CreateNativeSessionDescription(description, &error);
 490   if (!native_desc) {
 491     std::string reason_str = "Failed to parse SessionDescription. ";
 492     reason_str.append(error.line);
 493     reason_str.append(" ");
 494     reason_str.append(error.description);
 495     LOG(ERROR) << reason_str;
 496     request.requestFailed(blink::WebString::fromUTF8(reason_str));
 497     return;
 498   }
 499   if (peer_connection_tracker_)
 500     peer_connection_tracker_->TrackSetSessionDescription(
 501         this, description, PeerConnectionTracker::SOURCE_LOCAL);
 502
 503   scoped_refptr<SetSessionDescriptionRequest> set_request(
 504       new talk_base::RefCountedObject<SetSessionDescriptionRequest>(
 505           request, this, PeerConnectionTracker::ACTION_SET_LOCAL_DESCRIPTION));
 506   native_peer_connection_->SetLocalDescription(set_request.get(), native_desc);
 507 }
 508
 509 void RTCPeerConnectionHandler::setRemoteDescription(
 510     const blink::WebRTCVoidRequest& request,
 511     const blink::WebRTCSessionDescription& description) {
 512   webrtc::SdpParseError error;
 513   webrtc::SessionDescriptionInterface* native_desc =
 514       CreateNativeSessionDescription(description, &error);
 515   if (!native_desc) {
 516     std::string reason_str = "Failed to parse SessionDescription. ";
 517     reason_str.append(error.line);
 518     reason_str.append(" ");
 519     reason_str.append(error.description);
 520     LOG(ERROR) << reason_str;
 521     request.requestFailed(blink::WebString::fromUTF8(reason_str));
 522     return;
 523   }
 524   if (peer_connection_tracker_)
 525     peer_connection_tracker_->TrackSetSessionDescription(
 526         this, description, PeerConnectionTracker::SOURCE_REMOTE);
 527
 528   scoped_refptr<SetSessionDescriptionRequest> set_request(
 529       new talk_base::RefCountedObject<SetSessionDescriptionRequest>(
 530           request, this, PeerConnectionTracker::ACTION_SET_REMOTE_DESCRIPTION));
 531   native_peer_connection_->SetRemoteDescription(set_request.get(), native_desc);
 532 }
 533
 534 blink::WebRTCSessionDescription
 535 RTCPeerConnectionHandler::localDescription() {
 536   const webrtc::SessionDescriptionInterface* native_desc =
 537       native_peer_connection_->local_description();
 538   blink::WebRTCSessionDescription description =
 539       CreateWebKitSessionDescription(native_desc);
 540   return description;
 541 }
 542
 543 blink::WebRTCSessionDescription
 544 RTCPeerConnectionHandler::remoteDescription() {
 545   const webrtc::SessionDescriptionInterface* native_desc =
 546       native_peer_connection_->remote_description();
 547   blink::WebRTCSessionDescription description =
 548       CreateWebKitSessionDescription(native_desc);
 549   return description;
 550 }
 551
 552 bool RTCPeerConnectionHandler::updateICE(
 553     const blink::WebRTCConfiguration& server_configuration,
 554     const blink::WebMediaConstraints& options) {
 555   webrtc::PeerConnectionInterface::IceServers servers;
 556   GetNativeIceServers(server_configuration, &servers);
 557   RTCMediaConstraints constraints(options);
 558
 559   if (peer_connection_tracker_)
 560     peer_connection_tracker_->TrackUpdateIce(this, servers, constraints);
 561
 562   return native_peer_connection_->UpdateIce(servers,
 563                                             &constraints);
 564 }
 565
 566 bool RTCPeerConnectionHandler::addICECandidate(
 567   const blink::WebRTCVoidRequest& request,
 568   const blink::WebRTCICECandidate& candidate) {
 569   // Libjingle currently does not accept callbacks for addICECandidate.
 570   // For that reason we are going to call callbacks from here.
 571   bool result = addICECandidate(candidate);
 572   base::MessageLoop::current()->PostTask(
 573       FROM_HERE,
 574       base::Bind(&RTCPeerConnectionHandler::OnaddICECandidateResult,
 575                  base::Unretained(this), request, result));
 576   // On failure callback will be triggered.
 577   return true;
 578 }
 579
 580 bool RTCPeerConnectionHandler::addICECandidate(
 581     const blink::WebRTCICECandidate& candidate) {
 582   scoped_ptr<webrtc::IceCandidateInterface> native_candidate(
 583       dependency_factory_->CreateIceCandidate(
 584           base::UTF16ToUTF8(candidate.sdpMid()),
 585           candidate.sdpMLineIndex(),
 586           base::UTF16ToUTF8(candidate.candidate())));
 587   if (!native_candidate) {
 588     LOG(ERROR) << "Could not create native ICE candidate.";
 589     return false;
 590   }
 591
 592   bool return_value =
 593       native_peer_connection_->AddIceCandidate(native_candidate.get());
 594   LOG_IF(ERROR, !return_value) << "Error processing ICE candidate.";
 595
 596   if (peer_connection_tracker_)
 597     peer_connection_tracker_->TrackAddIceCandidate(
 598         this, candidate, PeerConnectionTracker::SOURCE_REMOTE);
 599
 600   return return_value;
 601 }
 602
 603 void RTCPeerConnectionHandler::OnaddICECandidateResult(
 604     const blink::WebRTCVoidRequest& webkit_request, bool result) {
 605   if (!result) {
 606     // We don't have the actual error code from the libjingle, so for now
 607     // using a generic error string.
 608     return webkit_request.requestFailed(
 609         base::UTF8ToUTF16("Error processing ICE candidate"));
 610   }
 611
 612   return webkit_request.requestSucceeded();
 613 }
 614
 615 bool RTCPeerConnectionHandler::addStream(
 616     const blink::WebMediaStream& stream,
 617     const blink::WebMediaConstraints& options) {
 618
 619   for (ScopedVector<WebRtcMediaStreamAdapter>::iterator adapter_it =
 620       local_streams_.begin(); adapter_it != local_streams_.end();
 621       ++adapter_it) {
 622     if ((*adapter_it)->IsEqual(stream)) {
 623       DVLOG(1) << "RTCPeerConnectionHandler::addStream called with the same "
 624                << "stream twice. id=" << stream.id().utf8();
 625       return false;
 626     }
 627   }
 628
 629   if (peer_connection_tracker_)
 630     peer_connection_tracker_->TrackAddStream(
 631         this, stream, PeerConnectionTracker::SOURCE_LOCAL);
 632
 633   PerSessionWebRTCAPIMetrics::GetInstance()->IncrementStreamCounter();
 634
 635   WebRtcMediaStreamAdapter* adapter =
 636       new WebRtcMediaStreamAdapter(stream, dependency_factory_);
 637   local_streams_.push_back(adapter);
 638
 639   webrtc::MediaStreamInterface* webrtc_stream = adapter->webrtc_media_stream();
 640   track_metrics_.AddStream(MediaStreamTrackMetrics::SENT_STREAM,
 641                            webrtc_stream);
 642
 643   RTCMediaConstraints constraints(options);
 644   return native_peer_connection_->AddStream(webrtc_stream, &constraints);
 645 }
 646
 647 void RTCPeerConnectionHandler::removeStream(
 648     const blink::WebMediaStream& stream) {
 649   // Find the webrtc stream.
 650   scoped_refptr<webrtc::MediaStreamInterface> webrtc_stream;
 651   for (ScopedVector<WebRtcMediaStreamAdapter>::iterator adapter_it =
 652            local_streams_.begin(); adapter_it != local_streams_.end();
 653        ++adapter_it) {
 654     if ((*adapter_it)->IsEqual(stream)) {
 655       webrtc_stream = (*adapter_it)->webrtc_media_stream();
 656       local_streams_.erase(adapter_it);
 657       break;
 658     }
 659   }
 660   DCHECK(webrtc_stream);
 661   native_peer_connection_->RemoveStream(webrtc_stream);
 662
 663   if (peer_connection_tracker_)
 664     peer_connection_tracker_->TrackRemoveStream(
 665         this, stream, PeerConnectionTracker::SOURCE_LOCAL);
 666   PerSessionWebRTCAPIMetrics::GetInstance()->DecrementStreamCounter();
 667   track_metrics_.RemoveStream(MediaStreamTrackMetrics::SENT_STREAM,
 668                               webrtc_stream);
 669 }
 670
 671 void RTCPeerConnectionHandler::getStats(
 672     const blink::WebRTCStatsRequest& request) {
 673   scoped_refptr<LocalRTCStatsRequest> inner_request(
 674       new talk_base::RefCountedObject<LocalRTCStatsRequest>(request));
 675   getStats(inner_request.get());
 676 }
 677
 678 void RTCPeerConnectionHandler::getStats(LocalRTCStatsRequest* request) {
 679   talk_base::scoped_refptr<webrtc::StatsObserver> observer(
 680       new talk_base::RefCountedObject<StatsResponse>(request));
 681   webrtc::MediaStreamTrackInterface* track = NULL;
 682   if (request->hasSelector()) {
 683     blink::WebMediaStreamSource::Type type =
 684         request->component().source().type();
 685     std::string track_id = request->component().id().utf8();
 686     if (type == blink::WebMediaStreamSource::TypeAudio) {
 687       track =
 688           native_peer_connection_->local_streams()->FindAudioTrack(track_id);
 689       if (!track) {
 690         track =
 691             native_peer_connection_->remote_streams()->FindAudioTrack(track_id);
 692       }
 693     } else {
 694       DCHECK_EQ(blink::WebMediaStreamSource::TypeVideo, type);
 695       track =
 696           native_peer_connection_->local_streams()->FindVideoTrack(track_id);
 697       if (!track) {
 698         track =
 699             native_peer_connection_->remote_streams()->FindVideoTrack(track_id);
 700       }
 701     }
 702     if (!track) {
 703       DVLOG(1) << "GetStats: Track not found.";
 704       // TODO(hta): Consider how to get an error back.
 705       std::vector<webrtc::StatsReport> no_reports;
 706       observer->OnComplete(no_reports);
 707       return;
 708     }
 709   }
 710   GetStats(observer,
 711            track,
 712            webrtc::PeerConnectionInterface::kStatsOutputLevelStandard);
 713 }
 714
 715 void RTCPeerConnectionHandler::GetStats(
 716     webrtc::StatsObserver* observer,
 717     webrtc::MediaStreamTrackInterface* track,
 718     webrtc::PeerConnectionInterface::StatsOutputLevel level) {
 719   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::GetStats");
 720   if (!native_peer_connection_->GetStats(observer, track, level)) {
 721     DVLOG(1) << "GetStats failed.";
 722     // TODO(hta): Consider how to get an error back.
 723     std::vector<webrtc::StatsReport> no_reports;
 724     observer->OnComplete(no_reports);
 725     return;
 726   }
 727 }
 728
 729 blink::WebRTCDataChannelHandler* RTCPeerConnectionHandler::createDataChannel(
 730     const blink::WebString& label, const blink::WebRTCDataChannelInit& init) {
 731   DVLOG(1) << "createDataChannel label " << base::UTF16ToUTF8(label);
 732
 733   webrtc::DataChannelInit config;
 734   // TODO(jiayl): remove the deprecated reliable field once Libjingle is updated
 735   // to handle that.
 736   config.reliable = false;
 737   config.id = init.id;
 738   config.ordered = init.ordered;
 739   config.negotiated = init.negotiated;
 740   config.maxRetransmits = init.maxRetransmits;
 741   config.maxRetransmitTime = init.maxRetransmitTime;
 742   config.protocol = base::UTF16ToUTF8(init.protocol);
 743
 744   talk_base::scoped_refptr<webrtc::DataChannelInterface> webrtc_channel(
 745       native_peer_connection_->CreateDataChannel(base::UTF16ToUTF8(label),
 746                                                  &config));
 747   if (!webrtc_channel) {
 748     DLOG(ERROR) << "Could not create native data channel.";
 749     return NULL;
 750   }
 751   if (peer_connection_tracker_)
 752     peer_connection_tracker_->TrackCreateDataChannel(
 753         this, webrtc_channel.get(), PeerConnectionTracker::SOURCE_LOCAL);
 754
 755   ++num_data_channels_created_;
 756
 757   return new RtcDataChannelHandler(webrtc_channel);
 758 }
 759
 760 blink::WebRTCDTMFSenderHandler* RTCPeerConnectionHandler::createDTMFSender(
 761     const blink::WebMediaStreamTrack& track) {
 762   DVLOG(1) << "createDTMFSender.";
 763
 764   MediaStreamTrack* native_track = MediaStreamTrack::GetTrack(track);
 765   if (!native_track ||
 766       track.source().type() != blink::WebMediaStreamSource::TypeAudio) {
 767     DLOG(ERROR) << "Could not create DTMF sender from a non-audio track.";
 768     return NULL;
 769   }
 770
 771   webrtc::AudioTrackInterface* audio_track = native_track->GetAudioAdapter();
 772   talk_base::scoped_refptr<webrtc::DtmfSenderInterface> sender(
 773       native_peer_connection_->CreateDtmfSender(audio_track));
 774   if (!sender) {
 775     DLOG(ERROR) << "Could not create native DTMF sender.";
 776     return NULL;
 777   }
 778   if (peer_connection_tracker_)
 779     peer_connection_tracker_->TrackCreateDTMFSender(this, track);
 780
 781   return new RtcDtmfSenderHandler(sender);
 782 }
 783
 784 void RTCPeerConnectionHandler::stop() {
 785   DVLOG(1) << "RTCPeerConnectionHandler::stop";
 786
 787   if (peer_connection_tracker_)
 788     peer_connection_tracker_->TrackStop(this);
 789   native_peer_connection_->Close();
 790 }
 791
 792 void RTCPeerConnectionHandler::OnError() {
 793   // TODO(perkj): Implement.
 794   NOTIMPLEMENTED();
 795 }
 796
 797 void RTCPeerConnectionHandler::OnSignalingChange(
 798     webrtc::PeerConnectionInterface::SignalingState new_state) {
 799   blink::WebRTCPeerConnectionHandlerClient::SignalingState state =
 800       GetWebKitSignalingState(new_state);
 801   if (peer_connection_tracker_)
 802     peer_connection_tracker_->TrackSignalingStateChange(this, state);
 803   client_->didChangeSignalingState(state);
 804 }
 805
 806 // Called any time the IceConnectionState changes
 807 void RTCPeerConnectionHandler::OnIceConnectionChange(
 808     webrtc::PeerConnectionInterface::IceConnectionState new_state) {
 809   track_metrics_.IceConnectionChange(new_state);
 810   blink::WebRTCPeerConnectionHandlerClient::ICEConnectionState state =
 811       GetWebKitIceConnectionState(new_state);
 812   if (peer_connection_tracker_)
 813     peer_connection_tracker_->TrackIceConnectionStateChange(this, state);
 814   client_->didChangeICEConnectionState(state);
 815 }
 816
 817 // Called any time the IceGatheringState changes
 818 void RTCPeerConnectionHandler::OnIceGatheringChange(
 819     webrtc::PeerConnectionInterface::IceGatheringState new_state) {
 820   if (new_state == webrtc::PeerConnectionInterface::kIceGatheringComplete) {
 821     // If ICE gathering is completed, generate a NULL ICE candidate,
 822     // to signal end of candidates.
 823     blink::WebRTCICECandidate null_candidate;
 824     client_->didGenerateICECandidate(null_candidate);
 825   }
 826
 827   blink::WebRTCPeerConnectionHandlerClient::ICEGatheringState state =
 828       GetWebKitIceGatheringState(new_state);
 829   if (peer_connection_tracker_)
 830     peer_connection_tracker_->TrackIceGatheringStateChange(this, state);
 831   client_->didChangeICEGatheringState(state);
 832 }
 833
 834 void RTCPeerConnectionHandler::OnAddStream(
 835     webrtc::MediaStreamInterface* stream_interface) {
 836   DCHECK(stream_interface);
 837   DCHECK(remote_streams_.find(stream_interface) == remote_streams_.end());
 838
 839   RemoteMediaStreamImpl* remote_stream =
 840       new RemoteMediaStreamImpl(stream_interface);
 841   remote_streams_.insert(
 842       std::pair<webrtc::MediaStreamInterface*, RemoteMediaStreamImpl*> (
 843           stream_interface, remote_stream));
 844
 845   if (peer_connection_tracker_)
 846     peer_connection_tracker_->TrackAddStream(
 847         this, remote_stream->webkit_stream(),
 848         PeerConnectionTracker::SOURCE_REMOTE);
 849
 850   PerSessionWebRTCAPIMetrics::GetInstance()->IncrementStreamCounter();
 851
 852   track_metrics_.AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM,
 853                            stream_interface);
 854
 855   client_->didAddRemoteStream(remote_stream->webkit_stream());
 856 }
 857
 858 void RTCPeerConnectionHandler::OnRemoveStream(
 859     webrtc::MediaStreamInterface* stream_interface) {
 860   DCHECK(stream_interface);
 861   RemoteStreamMap::iterator it = remote_streams_.find(stream_interface);
 862   if (it == remote_streams_.end()) {
 863     NOTREACHED() << "Stream not found";
 864     return;
 865   }
 866
 867   track_metrics_.RemoveStream(MediaStreamTrackMetrics::RECEIVED_STREAM,
 868                               stream_interface);
 869   PerSessionWebRTCAPIMetrics::GetInstance()->DecrementStreamCounter();
 870
 871   scoped_ptr<RemoteMediaStreamImpl> remote_stream(it->second);
 872   const blink::WebMediaStream& webkit_stream = remote_stream->webkit_stream();
 873   DCHECK(!webkit_stream.isNull());
 874   remote_streams_.erase(it);
 875
 876   if (peer_connection_tracker_)
 877     peer_connection_tracker_->TrackRemoveStream(
 878         this, webkit_stream, PeerConnectionTracker::SOURCE_REMOTE);
 879
 880   client_->didRemoveRemoteStream(webkit_stream);
 881 }
 882
 883 void RTCPeerConnectionHandler::OnIceCandidate(
 884     const webrtc::IceCandidateInterface* candidate) {
 885   DCHECK(candidate);
 886   std::string sdp;
 887   if (!candidate->ToString(&sdp)) {
 888     NOTREACHED() << "OnIceCandidate: Could not get SDP string.";
 889     return;
 890   }
 891   blink::WebRTCICECandidate web_candidate;
 892   web_candidate.initialize(base::UTF8ToUTF16(sdp),
 893                            base::UTF8ToUTF16(candidate->sdp_mid()),
 894                            candidate->sdp_mline_index());
 895   if (peer_connection_tracker_)
 896     peer_connection_tracker_->TrackAddIceCandidate(
 897         this, web_candidate, PeerConnectionTracker::SOURCE_LOCAL);
 898
 899   client_->didGenerateICECandidate(web_candidate);
 900 }
 901
 902 void RTCPeerConnectionHandler::OnDataChannel(
 903     webrtc::DataChannelInterface* data_channel) {
 904   if (peer_connection_tracker_)
 905     peer_connection_tracker_->TrackCreateDataChannel(
 906         this, data_channel, PeerConnectionTracker::SOURCE_REMOTE);
 907
 908   DVLOG(1) << "RTCPeerConnectionHandler::OnDataChannel "
 909            << data_channel->label();
 910   client_->didAddRemoteDataChannel(new RtcDataChannelHandler(data_channel));
 911 }
 912
 913 void RTCPeerConnectionHandler::OnRenegotiationNeeded() {
 914   if (peer_connection_tracker_)
 915     peer_connection_tracker_->TrackOnRenegotiationNeeded(this);
 916   client_->negotiationNeeded();
 917 }
 918
 919 PeerConnectionTracker* RTCPeerConnectionHandler::peer_connection_tracker() {
 920   return peer_connection_tracker_;
 921 }
 922
 923 webrtc::SessionDescriptionInterface*
 924 RTCPeerConnectionHandler::CreateNativeSessionDescription(
 925     const blink::WebRTCSessionDescription& description,
 926     webrtc::SdpParseError* error) {
 927   std::string sdp = base::UTF16ToUTF8(description.sdp());
 928   std::string type = base::UTF16ToUTF8(description.type());
 929   webrtc::SessionDescriptionInterface* native_desc =
 930       dependency_factory_->CreateSessionDescription(type, sdp, error);
 931
 932   LOG_IF(ERROR, !native_desc) << "Failed to create native session description."
 933                               << " Type: " << type << " SDP: " << sdp;
 934
 935   return native_desc;
 936 }
 937
 938 }  // namespace content