Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / third_party / libjingle / source / talk / app / webrtc / objc / RTCPeerConnection.mm

diff --git a/src/third_party/libjingle/source/talk/app/webrtc/objc/RTCPeerConnection.mm b/src/third_party/libjingle/source/talk/app/webrtc/objc/RTCPeerConnection.mm
index a7e31a1..72ba373 100644 (file)
--- a/src/third_party/libjingle/source/talk/app/webrtc/objc/RTCPeerConnection.mm
+++ b/src/third_party/libjingle/source/talk/app/webrtc/objc/RTCPeerConnection.mm
@@ -31,14 +31,19 @@
 
 #import "RTCPeerConnection+Internal.h"
 
+#import "RTCDataChannel+Internal.h"
 #import "RTCEnumConverter.h"
 #import "RTCICECandidate+Internal.h"
 #import "RTCICEServer+Internal.h"
 #import "RTCMediaConstraints+Internal.h"
 #import "RTCMediaStream+Internal.h"
+#import "RTCMediaStreamTrack+Internal.h"
+#import "RTCPeerConnectionObserver.h"
 #import "RTCSessionDescription+Internal.h"
-#import "RTCSessionDescriptonDelegate.h"
 #import "RTCSessionDescription.h"
+#import "RTCSessionDescriptionDelegate.h"
+#import "RTCStatsDelegate.h"
+#import "RTCStatsReport+Internal.h"
 
 #include "talk/app/webrtc/jsep.h"
 
@@ -50,8 +55,9 @@ namespace webrtc {
 class RTCCreateSessionDescriptionObserver
     : public CreateSessionDescriptionObserver {
  public:
-  RTCCreateSessionDescriptionObserver(id<RTCSessionDescriptonDelegate> delegate,
-                                      RTCPeerConnection* peerConnection) {
+  RTCCreateSessionDescriptionObserver(
+      id<RTCSessionDescriptionDelegate> delegate,
+      RTCPeerConnection* peerConnection) {
     _delegate = delegate;
     _peerConnection = peerConnection;
   }
@@ -76,13 +82,13 @@ class RTCCreateSessionDescriptionObserver
   }
 
  private:
-  id<RTCSessionDescriptonDelegate> _delegate;
+  id<RTCSessionDescriptionDelegate> _delegate;
   RTCPeerConnection* _peerConnection;
 };
 
 class RTCSetSessionDescriptionObserver : public SetSessionDescriptionObserver {
  public:
-  RTCSetSessionDescriptionObserver(id<RTCSessionDescriptonDelegate> delegate,
+  RTCSetSessionDescriptionObserver(id<RTCSessionDescriptionDelegate> delegate,
                                    RTCPeerConnection* peerConnection) {
     _delegate = delegate;
     _peerConnection = peerConnection;
@@ -104,19 +110,43 @@ class RTCSetSessionDescriptionObserver : public SetSessionDescriptionObserver {
   }
 
  private:
-  id<RTCSessionDescriptonDelegate> _delegate;
+  id<RTCSessionDescriptionDelegate> _delegate;
+  RTCPeerConnection* _peerConnection;
+};
+
+class RTCStatsObserver : public StatsObserver {
+ public:
+  RTCStatsObserver(id<RTCStatsDelegate> delegate,
+                   RTCPeerConnection* peerConnection) {
+    _delegate = delegate;
+    _peerConnection = peerConnection;
+  }
+
+  virtual void OnComplete(const std::vector<StatsReport>& reports) OVERRIDE {
+    NSMutableArray* stats = [NSMutableArray arrayWithCapacity:reports.size()];
+    std::vector<StatsReport>::const_iterator it = reports.begin();
+    for (; it != reports.end(); ++it) {
+      RTCStatsReport* statsReport =
+          [[RTCStatsReport alloc] initWithStatsReport:*it];
+      [stats addObject:statsReport];
+    }
+    [_delegate peerConnection:_peerConnection didGetStats:stats];
+  }
+
+ private:
+  id<RTCStatsDelegate> _delegate;
   RTCPeerConnection* _peerConnection;
 };
 }
 
 @implementation RTCPeerConnection {
   NSMutableArray* _localStreams;
-  talk_base::scoped_ptr<webrtc::RTCPeerConnectionObserver> _observer;
-  talk_base::scoped_refptr<webrtc::PeerConnectionInterface> _peerConnection;
+  rtc::scoped_ptr<webrtc::RTCPeerConnectionObserver> _observer;
+  rtc::scoped_refptr<webrtc::PeerConnectionInterface> _peerConnection;
 }
 
 - (BOOL)addICECandidate:(RTCICECandidate*)candidate {
-  talk_base::scoped_ptr<const webrtc::IceCandidateInterface> iceCandidate(
+  rtc::scoped_ptr<const webrtc::IceCandidateInterface> iceCandidate(
       candidate.candidate);
   return self.peerConnection->AddIceCandidate(iceCandidate.get());
 }
@@ -132,18 +162,27 @@ class RTCSetSessionDescriptionObserver : public SetSessionDescriptionObserver {
   return YES;
 }
 
-- (void)createAnswerWithDelegate:(id<RTCSessionDescriptonDelegate>)delegate
+- (RTCDataChannel*)createDataChannelWithLabel:(NSString*)label
+                                       config:(RTCDataChannelInit*)config {
+  std::string labelString([label UTF8String]);
+  rtc::scoped_refptr<webrtc::DataChannelInterface> dataChannel =
+      self.peerConnection->CreateDataChannel(labelString,
+                                             config.dataChannelInit);
+  return [[RTCDataChannel alloc] initWithDataChannel:dataChannel];
+}
+
+- (void)createAnswerWithDelegate:(id<RTCSessionDescriptionDelegate>)delegate
                      constraints:(RTCMediaConstraints*)constraints {
-  talk_base::scoped_refptr<webrtc::RTCCreateSessionDescriptionObserver>
-      observer(new talk_base::RefCountedObject<
+  rtc::scoped_refptr<webrtc::RTCCreateSessionDescriptionObserver>
+      observer(new rtc::RefCountedObject<
           webrtc::RTCCreateSessionDescriptionObserver>(delegate, self));
   self.peerConnection->CreateAnswer(observer, constraints.constraints);
 }
 
-- (void)createOfferWithDelegate:(id<RTCSessionDescriptonDelegate>)delegate
+- (void)createOfferWithDelegate:(id<RTCSessionDescriptionDelegate>)delegate
                     constraints:(RTCMediaConstraints*)constraints {
-  talk_base::scoped_refptr<webrtc::RTCCreateSessionDescriptionObserver>
-      observer(new talk_base::RefCountedObject<
+  rtc::scoped_refptr<webrtc::RTCCreateSessionDescriptionObserver>
+      observer(new rtc::RefCountedObject<
           webrtc::RTCCreateSessionDescriptionObserver>(delegate, self));
   self.peerConnection->CreateOffer(observer, constraints.constraints);
 }
@@ -154,19 +193,19 @@ class RTCSetSessionDescriptionObserver : public SetSessionDescriptionObserver {
 }
 
 - (void)setLocalDescriptionWithDelegate:
-            (id<RTCSessionDescriptonDelegate>)delegate
+            (id<RTCSessionDescriptionDelegate>)delegate
                      sessionDescription:(RTCSessionDescription*)sdp {
-  talk_base::scoped_refptr<webrtc::RTCSetSessionDescriptionObserver> observer(
-      new talk_base::RefCountedObject<webrtc::RTCSetSessionDescriptionObserver>(
+  rtc::scoped_refptr<webrtc::RTCSetSessionDescriptionObserver> observer(
+      new rtc::RefCountedObject<webrtc::RTCSetSessionDescriptionObserver>(
           delegate, self));
   self.peerConnection->SetLocalDescription(observer, sdp.sessionDescription);
 }
 
 - (void)setRemoteDescriptionWithDelegate:
-            (id<RTCSessionDescriptonDelegate>)delegate
+            (id<RTCSessionDescriptionDelegate>)delegate
                       sessionDescription:(RTCSessionDescription*)sdp {
-  talk_base::scoped_refptr<webrtc::RTCSetSessionDescriptionObserver> observer(
-      new talk_base::RefCountedObject<webrtc::RTCSetSessionDescriptionObserver>(
+  rtc::scoped_refptr<webrtc::RTCSetSessionDescriptionObserver> observer(
+      new rtc::RefCountedObject<webrtc::RTCSetSessionDescriptionObserver>(
           delegate, self));
   self.peerConnection->SetRemoteDescription(observer, sdp.sessionDescription);
 }
@@ -219,28 +258,36 @@ class RTCSetSessionDescriptionObserver : public SetSessionDescriptionObserver {
   self.peerConnection->Close();
 }
 
+- (BOOL)getStatsWithDelegate:(id<RTCStatsDelegate>)delegate
+            mediaStreamTrack:(RTCMediaStreamTrack*)mediaStreamTrack
+            statsOutputLevel:(RTCStatsOutputLevel)statsOutputLevel {
+  rtc::scoped_refptr<webrtc::RTCStatsObserver> observer(
+      new rtc::RefCountedObject<webrtc::RTCStatsObserver>(delegate,
+                                                                self));
+  webrtc::PeerConnectionInterface::StatsOutputLevel nativeOutputLevel =
+      [RTCEnumConverter convertStatsOutputLevelToNative:statsOutputLevel];
+  return self.peerConnection->GetStats(
+      observer, mediaStreamTrack.mediaTrack, nativeOutputLevel);
+}
+
 @end
 
 @implementation RTCPeerConnection (Internal)
 
-- (id)initWithPeerConnection:
-          (talk_base::scoped_refptr<webrtc::PeerConnectionInterface>)
-      peerConnection
-                    observer:(webrtc::RTCPeerConnectionObserver*)observer {
-  if (!peerConnection || !observer) {
-    NSAssert(NO, @"nil arguments not allowed");
-    self = nil;
-    return nil;
-  }
-  if ((self = [super init])) {
-    _peerConnection = peerConnection;
+- (instancetype)initWithFactory:(webrtc::PeerConnectionFactoryInterface*)factory
+     iceServers:(const webrtc::PeerConnectionInterface::IceServers&)iceServers
+    constraints:(const webrtc::MediaConstraintsInterface*)constraints {
+  NSParameterAssert(factory != NULL);
+  if (self = [super init]) {
+    _observer.reset(new webrtc::RTCPeerConnectionObserver(self));
+    _peerConnection = factory->CreatePeerConnection(
+        iceServers, constraints, NULL, NULL, _observer.get());
     _localStreams = [[NSMutableArray alloc] init];
-    _observer.reset(observer);
   }
   return self;
 }
 
-- (talk_base::scoped_refptr<webrtc::PeerConnectionInterface>)peerConnection {
+- (rtc::scoped_refptr<webrtc::PeerConnectionInterface>)peerConnection {
   return _peerConnection;
 }