Update API for Objective-C RTCPeerConnection.

webrtc/api/objc/RTCPeerConnection.mm

+/*
+ *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#import "RTCPeerConnection.h"
+
+#import "webrtc/api/objc/RTCPeerConnection+Private.h"
+#import "webrtc/api/objc/RTCConfiguration+Private.h"
+#import "webrtc/api/objc/RTCDataChannel+Private.h"
+#import "webrtc/api/objc/RTCDataChannelConfiguration+Private.h"
+#import "webrtc/api/objc/RTCIceCandidate+Private.h"
+#import "webrtc/api/objc/RTCMediaConstraints+Private.h"
+#import "webrtc/api/objc/RTCMediaStream+Private.h"
+#import "webrtc/api/objc/RTCMediaStreamTrack+Private.h"
+#import "webrtc/api/objc/RTCPeerConnectionFactory+Private.h"
+#import "webrtc/api/objc/RTCPeerConnectionObserver.h"
+#import "webrtc/api/objc/RTCSessionDescription+Private.h"
+#import "webrtc/api/objc/RTCStatsReport+Private.h"
+#import "webrtc/base/objc/NSString+StdString.h"
+
+NSString* const kRTCSessionDescriptionDelegateErrorDomain = @"RTCSDPError";

[tkchin_webrtc, 2016/02/01 10:00:02]

Should be kRTCPeerConnectionErrorDomain that's extern-ed in header.
"org.webrtc.RTCPeerConnection"
and then an error code for sdp error

[hjon_webrtc, 2016/02/04 00:58:37]

Done.

+int const kRTCSessionDescriptionDelegateErrorCode = -1;
+
+namespace webrtc {
+
+class RTCCreateSessionDescriptionObserver

[tkchin_webrtc, 2016/02/01 10:00:01]

following our previous precedence, let's not add RTC prefix to things already in
webrtc namespace

maybe CreateSessionDescriptionObserverAdapter

similarly for rest of C++ interfaces here.

[hjon_webrtc, 2016/02/04 00:58:38]

Done.

+    : public CreateSessionDescriptionObserver {
+ public:
+  RTCCreateSessionDescriptionObserver(
+      RTCPeerConnection *peerConnection,
+      void (^completionHandler)
+          (RTCSessionDescription *sessionDescription, NSError *error)) {
+    peerConnection_ = peerConnection;

[tkchin_webrtc, 2016/02/01 10:00:02]

doco why we need to keep a peer_connection strong pointer / retain cycle.

suggest releasing the peerconnection and the block the moment we get
OnSuccess/OnFailure and we're done with them.

ditto for other observers here

[tkchin_webrtc, 2016/02/01 10:00:02]

c++ style: peer_connection_ (or peerconnection_), completion_handler etc.
here and rest of file

[hjon_webrtc, 2016/02/04 00:58:37]

Done.

[hjon_webrtc, 2016/02/04 00:58:38]

Whoops, looks like this is a case of me not paying enough attention when
adapting the old implementation. We shouldn't need a strong pointer to the peer
connection.

[hjon_webrtc, 2016/02/04 00:58:38]

Done.

+    completionHandler_ = completionHandler;
+  }
+
+  void OnSuccess(SessionDescriptionInterface *desc) override {

[tkchin_webrtc, 2016/02/01 10:00:01]

for sanity, explicitly set ivars to nil in dtor

[hjon_webrtc, 2016/02/04 00:58:38]

Done.

+    RTCSessionDescription *session =
+        [[RTCSessionDescription alloc] initWithNativeDescription:desc];
+    if (completionHandler_) {
+      completionHandler_(session, nil);
+    }
+    delete desc;

[tkchin_webrtc, 2016/02/01 10:00:01]

use a scoped_ptr instead of explicitly calling delete

[hjon_webrtc, 2016/02/04 00:58:38]

Done.

+  }
+
+  void OnFailure(const std::string& error) override {
+    NSString *str = @(error.c_str());
+    NSError *err =
+        [NSError errorWithDomain:kRTCSessionDescriptionDelegateErrorDomain
+                            code:kRTCSessionDescriptionDelegateErrorCode
+                        userInfo:@{@"error" : str}];

[tkchin_webrtc, 2016/02/01 10:00:02]

use NSError standard keys
here maybe you want the localized description key

[hjon_webrtc, 2016/02/04 00:58:38]

Done.

+    if (completionHandler_) {
+      completionHandler_(nil, err);
+    }
+  }
+
+ private:
+  RTCPeerConnection* peerConnection_;
+  void (^completionHandler_)
+      (RTCSessionDescription *sessionDescription, NSError *error);
+};
+
+class RTCSetSessionDescriptionObserver : public SetSessionDescriptionObserver {
+ public:
+  RTCSetSessionDescriptionObserver(
+      RTCPeerConnection *peerConnection,
+      void (^completionHandler)(NSError *error)) {
+    peerConnection_ = peerConnection;
+    completionHandler_ = completionHandler;
+  }
+
+  void OnSuccess() override {
+    if (completionHandler_) {
+      completionHandler_(nil);
+    }
+  }
+
+  void OnFailure(const std::string& error) override {
+    NSString *str = @(error.c_str());
+    NSError *err =
+        [NSError errorWithDomain:kRTCSessionDescriptionDelegateErrorDomain
+                            code:kRTCSessionDescriptionDelegateErrorCode
+                        userInfo:@{@"error" : str}];

[tkchin_webrtc, 2016/02/01 10:00:01]

ditto

[hjon_webrtc, 2016/02/04 00:58:38]

Done.

+    if (completionHandler_) {
+      completionHandler_(err);
+    }
+  }
+
+ private:
+  RTCPeerConnection* peerConnection_;
+  void (^completionHandler_)(NSError *error);
+};
+
+class RTCStatsObserver : public StatsObserver {
+ public:
+  RTCStatsObserver(RTCPeerConnection *peerConnection,
+                   void (^completionHandler)
+        (NSArray<RTCStatsReport *> *stats)) {
+    peerConnection_ = peerConnection;
+    completionHandler_ = completionHandler;
+  }
+
+  void OnComplete(const StatsReports& reports) override {
+    NSMutableArray *stats = [NSMutableArray arrayWithCapacity:reports.size()];
+    for (const auto* report : reports) {
+      RTCStatsReport *statsReport =
+          [[RTCStatsReport alloc] initWithNativeReport:*report];
+      [stats addObject:statsReport];
+    }
+    if (completionHandler_) {
+      completionHandler_(stats);
+    }
+  }
+
+ private:
+  RTCPeerConnection *peerConnection_;
+  void (^completionHandler_)(NSArray *stats);
+};
+}
+
+
+@implementation RTCPeerConnection {
+  NSMutableArray *_localStreams;
+  rtc::scoped_ptr<webrtc::PeerConnectionDelegateAdapter> _observer;
+  rtc::scoped_refptr<webrtc::PeerConnectionInterface> _peerConnection;
+}
+
+@synthesize delegate = _delegate;
+
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
+                  configuration:(nullable RTCConfiguration *)configuration
+                    constraints:(RTCMediaConstraints *)constraints
+                       delegate:(id<RTCPeerConnectionDelegate>)delegate {
+  NSParameterAssert(factory);
+  if (self = [super init]) {
+    _observer.reset(new webrtc::PeerConnectionDelegateAdapter(self));
+    webrtc::PeerConnectionInterface::RTCConfiguration config =
+        configuration.nativeConfiguration;

[tkchin_webrtc, 2016/02/01 10:00:02]

what happens here if configuration is nil? Will this be nullptr? Is that legal
for CreatePeerConnection?

[hjon_webrtc, 2016/02/04 00:58:38]

I guess I addressed this in RTCPeerConnection.h, but it looks like it's not
legal.

+    webrtc::MediaConstraints *nativeConstraints =
+        constraints.nativeConstraints.get();
+    _peerConnection =
+        factory.nativeFactory->CreatePeerConnection(config,
+                                                    nativeConstraints,
+                                                    nullptr,
+                                                    nullptr,
+                                                    _observer.get());
+    _localStreams = [[NSMutableArray alloc] init];
+    _delegate = delegate;
+  }
+  return self;
+}
+
+- (NSArray *)localStreams {
+  return [_localStreams copy];
+}
+
+- (RTCSessionDescription *)localDescription {
+  const webrtc::SessionDescriptionInterface *sdi =

[tkchin_webrtc, 2016/02/01 10:00:02]

nit: description not sdi

[hjon_webrtc, 2016/02/04 00:58:38]

Done.

+      _peerConnection->local_description();
+  return sdi ? [[RTCSessionDescription alloc] initWithNativeDescription:sdi]
+             : nil;
+}
+
+- (RTCSessionDescription *)remoteDescription {
+  const webrtc::SessionDescriptionInterface *sdi =

[tkchin_webrtc, 2016/02/01 10:00:01]

ditto

[hjon_webrtc, 2016/02/04 00:58:37]

Done.

+      _peerConnection->remote_description();
+  return sdi ? [[RTCSessionDescription alloc] initWithNativeDescription:sdi]
+             : nil;
+}
+
+- (RTCSignalingState)signalingState {
+  return [[self class]
+      signalingStateForNativeState:_peerConnection->signaling_state()];
+}
+
+- (RTCIceConnectionState)iceConnectionState {
+  return [[self class] iceConnectionStateForNativeState:
+      _peerConnection->ice_connection_state()];
+}
+
+- (RTCIceGatheringState)iceGatheringState {
+  return [[self class] iceGatheringStateForNativeState:
+      _peerConnection->ice_gathering_state()];
+}
+
+- (void)close {
+  _peerConnection->Close();
+}
+
+- (void)addIceCandidate:(RTCIceCandidate *)candidate {
+  rtc::scoped_ptr<const webrtc::IceCandidateInterface> iceCandidate(
+      candidate.nativeCandidate);
+  _peerConnection->AddIceCandidate(iceCandidate.get());
+}
+
+- (void)addStream:(RTCMediaStream *)stream {
+  BOOL ret = _peerConnection->AddStream(stream.nativeMediaStream);
+  if (!ret) {

[tkchin_webrtc, 2016/02/01 10:00:01]

collapse the two lines and log error if failure

[hjon_webrtc, 2016/02/04 00:58:37]

Done.

+    return;
+  }
+  [_localStreams addObject:stream];
+}
+
+- (void)removeStream:(RTCMediaStream *)stream {
+  _peerConnection->RemoveStream(stream.nativeMediaStream);
+  [_localStreams removeObject:stream];
+}
+
+- (RTCDataChannel *)createDataChannelWithLabel:(NSString *)label
+                                 configuration:
+    (RTCDataChannelConfiguration *)configuration {
+  std::string labelString = [NSString stdStringForString:label];
+  const webrtc::DataChannelInit nativeInit =
+      configuration.nativeDataChannelInit;
+  rtc::scoped_refptr<webrtc::DataChannelInterface> dataChannel =
+      _peerConnection->CreateDataChannel(labelString,
+                                         &nativeInit);
+  return [[RTCDataChannel alloc] initWithNativeDataChannel:dataChannel];
+}
+
+- (void)createOfferWithConstraints:(RTCMediaConstraints *)constraints
+                 completionHandler:
+    (void (^)(RTCSessionDescription *sessionDescription, NSError *error))
+        completionHandler {
+  rtc::scoped_refptr<webrtc::RTCCreateSessionDescriptionObserver>
+      observer(new rtc::RefCountedObject
+          <webrtc::RTCCreateSessionDescriptionObserver>(self,
+                                                        completionHandler));
+  _peerConnection->CreateOffer(observer, constraints.nativeConstraints.get());
+}
+
+- (void)createAnswerWithConstraints:(RTCMediaConstraints *)constraints
+                  completionHandler:
+    (void (^)(RTCSessionDescription *sessionDescription, NSError *error))
+        completionHandler {
+  rtc::scoped_refptr<webrtc::RTCCreateSessionDescriptionObserver>
+      observer(new rtc::RefCountedObject
+          <webrtc::RTCCreateSessionDescriptionObserver>(self,
+                                                        completionHandler));
+  _peerConnection->CreateAnswer(observer, constraints.nativeConstraints.get());
+}
+
+- (void)setLocalDescription:(RTCSessionDescription *)sdp
+          completionHandler:(void (^)(NSError *error))completionHandler {
+  rtc::scoped_refptr<webrtc::RTCSetSessionDescriptionObserver> observer(
+      new rtc::RefCountedObject<webrtc::RTCSetSessionDescriptionObserver>
+          (self, completionHandler));
+  _peerConnection->SetLocalDescription(observer, sdp.nativeDescription);
+}
+
+- (void)setRemoteDescription:(RTCSessionDescription *)sdp
+           completionHandler:(void (^)(NSError *error))completionHandler {
+  rtc::scoped_refptr<webrtc::RTCSetSessionDescriptionObserver> observer(
+      new rtc::RefCountedObject<webrtc::RTCSetSessionDescriptionObserver>
+          (self, completionHandler));
+  _peerConnection->SetRemoteDescription(observer, sdp.nativeDescription);
+}
+
+- (void)getStatsForMediaStreamTrack:(RTCMediaStreamTrack *)mediaStreamTrack
+                   statsOutputLevel:(RTCStatsOutputLevel)statsOutputLevel
+                  completionHandler:
+    (void (^)(NSArray<RTCStatsReport *> *stats))completionHandler {
+  rtc::scoped_refptr<webrtc::RTCStatsObserver> observer(
+      new rtc::RefCountedObject<webrtc::RTCStatsObserver>(self,
+                                                          completionHandler));
+  webrtc::PeerConnectionInterface::StatsOutputLevel nativeOutputLevel =
+      [[self class] nativeStatsOutputLevelForLevel:statsOutputLevel];
+  _peerConnection->GetStats(
+      observer, mediaStreamTrack.nativeTrack, nativeOutputLevel);
+}
+
+#pragma mark - Private
+
+- (rtc::scoped_refptr<webrtc::PeerConnectionInterface>)nativePeerConnection {
+  return _peerConnection;
+}
+
++ (webrtc::PeerConnectionInterface::SignalingState)nativeSignalingStateForState:
+    (RTCSignalingState)state {
+  switch (state) {
+    case RTCSignalingStateStable:
+      return webrtc::PeerConnectionInterface::kStable;
+    case RTCSignalingStateHaveLocalOffer:
+      return webrtc::PeerConnectionInterface::kHaveLocalOffer;
+    case RTCSignalingStateHaveLocalPrAnswer:
+      return webrtc::PeerConnectionInterface::kHaveLocalPrAnswer;
+    case RTCSignalingStateHaveRemoteOffer:
+      return webrtc::PeerConnectionInterface::kHaveRemoteOffer;
+    case RTCSignalingStateHaveRemotePrAnswer:
+      return webrtc::PeerConnectionInterface::kHaveRemotePrAnswer;
+    case RTCSignalingStateClosed:
+      return webrtc::PeerConnectionInterface::kClosed;
+  }
+}
+
++ (RTCSignalingState)signalingStateForNativeState:
+    (webrtc::PeerConnectionInterface::SignalingState)nativeState {
+  switch (nativeState) {
+    case webrtc::PeerConnectionInterface::kStable:
+      return RTCSignalingStateStable;
+    case webrtc::PeerConnectionInterface::kHaveLocalOffer:
+      return RTCSignalingStateHaveLocalOffer;
+    case webrtc::PeerConnectionInterface::kHaveLocalPrAnswer:
+      return RTCSignalingStateHaveLocalPrAnswer;
+    case webrtc::PeerConnectionInterface::kHaveRemoteOffer:
+      return RTCSignalingStateHaveRemoteOffer;
+    case webrtc::PeerConnectionInterface::kHaveRemotePrAnswer:
+      return RTCSignalingStateHaveRemotePrAnswer;
+    case webrtc::PeerConnectionInterface::kClosed:
+      return RTCSignalingStateClosed;
+  }
+}
+
++ (NSString *)stringForSignalingState:(RTCSignalingState)state {
+  switch (state) {
+    case RTCSignalingStateStable:
+      return @"Stable";

[tkchin_webrtc, 2016/02/01 10:00:01]

nit: all caps
STABLE
HAVE_LOCAL_OFFER
etc.

[hjon_webrtc, 2016/02/04 00:58:38]

Done.

+    case RTCSignalingStateHaveLocalOffer:
+      return @"Have local offer";
+    case RTCSignalingStateHaveLocalPrAnswer:
+      return @"Have local pranswer";
+    case RTCSignalingStateHaveRemoteOffer:
+      return @"Have remote offer";
+    case RTCSignalingStateHaveRemotePrAnswer:
+      return @"Have remote pranswer";
+    case RTCSignalingStateClosed:
+      return @"Closed";
+  }
+}
+
++ (webrtc::PeerConnectionInterface::IceConnectionState)
+    nativeIceConnectionStateForState:(RTCIceConnectionState)state {
+  switch (state) {
+    case RTCIceConnectionStateNew:
+      return webrtc::PeerConnectionInterface::kIceConnectionNew;
+    case RTCIceConnectionStateChecking:
+      return webrtc::PeerConnectionInterface::kIceConnectionChecking;
+    case RTCIceConnectionStateConnected:
+      return webrtc::PeerConnectionInterface::kIceConnectionConnected;
+    case RTCIceConnectionStateCompleted:
+      return webrtc::PeerConnectionInterface::kIceConnectionCompleted;
+    case RTCIceConnectionStateFailed:
+      return webrtc::PeerConnectionInterface::kIceConnectionFailed;
+    case RTCIceConnectionStateDisconnected:
+      return webrtc::PeerConnectionInterface::kIceConnectionDisconnected;
+    case RTCIceConnectionStateClosed:
+      return webrtc::PeerConnectionInterface::kIceConnectionClosed;
+    case RTCIceConnectionStateMax:
+      return webrtc::PeerConnectionInterface::kIceConnectionMax;
+  }
+}
+
++ (RTCIceConnectionState)iceConnectionStateForNativeState:
+    (webrtc::PeerConnectionInterface::IceConnectionState)nativeState {
+  switch (nativeState) {
+    case webrtc::PeerConnectionInterface::kIceConnectionNew:
+      return RTCIceConnectionStateNew;
+    case webrtc::PeerConnectionInterface::kIceConnectionChecking:
+      return RTCIceConnectionStateChecking;
+    case webrtc::PeerConnectionInterface::kIceConnectionConnected:
+      return RTCIceConnectionStateConnected;
+    case webrtc::PeerConnectionInterface::kIceConnectionCompleted:
+      return RTCIceConnectionStateCompleted;
+    case webrtc::PeerConnectionInterface::kIceConnectionFailed:
+      return RTCIceConnectionStateFailed;
+    case webrtc::PeerConnectionInterface::kIceConnectionDisconnected:
+      return RTCIceConnectionStateDisconnected;
+    case webrtc::PeerConnectionInterface::kIceConnectionClosed:
+      return RTCIceConnectionStateClosed;
+    case webrtc::PeerConnectionInterface::kIceConnectionMax:
+      return RTCIceConnectionStateMax;
+  }
+}
+
++ (NSString *)stringForIceConnectionState:(RTCIceConnectionState)state {
+  switch (state) {
+    case RTCIceConnectionStateNew:
+      return @"New";

[tkchin_webrtc, 2016/02/01 10:00:01]

ditto all caps

[hjon_webrtc, 2016/02/04 00:58:37]

Done.

+    case RTCIceConnectionStateChecking:
+      return @"Checking";
+    case RTCIceConnectionStateConnected:
+      return @"Connected";
+    case RTCIceConnectionStateCompleted:
+      return @"Completed";
+    case RTCIceConnectionStateFailed:
+      return @"Failed";
+    case RTCIceConnectionStateDisconnected:
+      return @"Disconnected";
+    case RTCIceConnectionStateClosed:
+      return @"Closed";
+    case RTCIceConnectionStateMax:
+      return @"Max";
+  }
+}
+
++ (webrtc::PeerConnectionInterface::IceGatheringState)
+    nativeIceGatheringStateForState:(RTCIceGatheringState)state {
+  switch (state) {
+    case RTCIceGatheringStateNew:
+      return webrtc::PeerConnectionInterface::kIceGatheringNew;
+    case RTCIceGatheringStateGathering:
+      return webrtc::PeerConnectionInterface::kIceGatheringGathering;
+    case RTCIceGatheringStateComplete:
+      return webrtc::PeerConnectionInterface::kIceGatheringComplete;
+  }
+}
+
++ (RTCIceGatheringState)iceGatheringStateForNativeState:
+    (webrtc::PeerConnectionInterface::IceGatheringState)nativeState {
+  switch (nativeState) {
+    case webrtc::PeerConnectionInterface::kIceGatheringNew:
+      return RTCIceGatheringStateNew;
+    case webrtc::PeerConnectionInterface::kIceGatheringGathering:
+      return RTCIceGatheringStateGathering;
+    case webrtc::PeerConnectionInterface::kIceGatheringComplete:
+      return RTCIceGatheringStateComplete;
+  }
+}
+
++ (NSString *)stringForIceGatheringState:(RTCIceGatheringState)state {
+  switch (state) {
+    case RTCIceGatheringStateNew:
+      return @"New";

[tkchin_webrtc, 2016/02/01 10:00:02]

ditto all caps

[hjon_webrtc, 2016/02/04 00:58:38]

Done.

+    case RTCIceGatheringStateGathering:
+      return @"Gathering";
+    case RTCIceGatheringStateComplete:
+      return @"Complete";
+  }
+}
+
++ (webrtc::PeerConnectionInterface::StatsOutputLevel)
+    nativeStatsOutputLevelForLevel:(RTCStatsOutputLevel)level {
+  switch (level) {
+    case RTCStatsOutputLevelStandard:
+      return webrtc::PeerConnectionInterface::kStatsOutputLevelStandard;
+    case RTCStatsOutputLevelDebug:
+      return webrtc::PeerConnectionInterface::kStatsOutputLevelDebug;
+  }
+}
+
+@end