Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(693)

Unified Diff: webrtc/sdk/objc/Framework/Classes/PeerConnection/RTCPeerConnection.mm

Issue 2890513002: Revert of Split iOS sdk in to separate targets (Closed)
Patch Set: Created 3 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: webrtc/sdk/objc/Framework/Classes/PeerConnection/RTCPeerConnection.mm
diff --git a/webrtc/sdk/objc/Framework/Classes/PeerConnection/RTCPeerConnection.mm b/webrtc/sdk/objc/Framework/Classes/PeerConnection/RTCPeerConnection.mm
deleted file mode 100644
index 311e0dd886e49a37d33ea0d3dbfe30e93868600e..0000000000000000000000000000000000000000
--- a/webrtc/sdk/objc/Framework/Classes/PeerConnection/RTCPeerConnection.mm
+++ /dev/null
@@ -1,601 +0,0 @@
-/*
- * 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+Private.h"
-
-#import "NSString+StdString.h"
-#import "RTCConfiguration+Private.h"
-#import "RTCDataChannel+Private.h"
-#import "RTCIceCandidate+Private.h"
-#import "RTCLegacyStatsReport+Private.h"
-#import "RTCMediaConstraints+Private.h"
-#import "RTCMediaStream+Private.h"
-#import "RTCPeerConnectionFactory+Private.h"
-#import "RTCRtpReceiver+Private.h"
-#import "RTCRtpSender+Private.h"
-#import "RTCSessionDescription+Private.h"
-#import "WebRTC/RTCLogging.h"
-
-#include <memory>
-
-#include "webrtc/api/jsepicecandidate.h"
-#include "webrtc/base/checks.h"
-
-NSString * const kRTCPeerConnectionErrorDomain =
- @"org.webrtc.RTCPeerConnection";
-int const kRTCPeerConnnectionSessionDescriptionError = -1;
-
-namespace webrtc {
-
-class CreateSessionDescriptionObserverAdapter
- : public CreateSessionDescriptionObserver {
- public:
- CreateSessionDescriptionObserverAdapter(
- void (^completionHandler)(RTCSessionDescription *sessionDescription,
- NSError *error)) {
- completion_handler_ = completionHandler;
- }
-
- ~CreateSessionDescriptionObserverAdapter() {
- completion_handler_ = nil;
- }
-
- void OnSuccess(SessionDescriptionInterface *desc) override {
- RTC_DCHECK(completion_handler_);
- std::unique_ptr<webrtc::SessionDescriptionInterface> description =
- std::unique_ptr<webrtc::SessionDescriptionInterface>(desc);
- RTCSessionDescription* session =
- [[RTCSessionDescription alloc] initWithNativeDescription:
- description.get()];
- completion_handler_(session, nil);
- completion_handler_ = nil;
- }
-
- void OnFailure(const std::string& error) override {
- RTC_DCHECK(completion_handler_);
- NSString* str = [NSString stringForStdString:error];
- NSError* err =
- [NSError errorWithDomain:kRTCPeerConnectionErrorDomain
- code:kRTCPeerConnnectionSessionDescriptionError
- userInfo:@{ NSLocalizedDescriptionKey : str }];
- completion_handler_(nil, err);
- completion_handler_ = nil;
- }
-
- private:
- void (^completion_handler_)
- (RTCSessionDescription *sessionDescription, NSError *error);
-};
-
-class SetSessionDescriptionObserverAdapter :
- public SetSessionDescriptionObserver {
- public:
- SetSessionDescriptionObserverAdapter(void (^completionHandler)
- (NSError *error)) {
- completion_handler_ = completionHandler;
- }
-
- ~SetSessionDescriptionObserverAdapter() {
- completion_handler_ = nil;
- }
-
- void OnSuccess() override {
- RTC_DCHECK(completion_handler_);
- completion_handler_(nil);
- completion_handler_ = nil;
- }
-
- void OnFailure(const std::string& error) override {
- RTC_DCHECK(completion_handler_);
- NSString* str = [NSString stringForStdString:error];
- NSError* err =
- [NSError errorWithDomain:kRTCPeerConnectionErrorDomain
- code:kRTCPeerConnnectionSessionDescriptionError
- userInfo:@{ NSLocalizedDescriptionKey : str }];
- completion_handler_(err);
- completion_handler_ = nil;
- }
-
- private:
- void (^completion_handler_)(NSError *error);
-};
-
-PeerConnectionDelegateAdapter::PeerConnectionDelegateAdapter(
- RTCPeerConnection *peerConnection) {
- peer_connection_ = peerConnection;
-}
-
-PeerConnectionDelegateAdapter::~PeerConnectionDelegateAdapter() {
- peer_connection_ = nil;
-}
-
-void PeerConnectionDelegateAdapter::OnSignalingChange(
- PeerConnectionInterface::SignalingState new_state) {
- RTCSignalingState state =
- [[RTCPeerConnection class] signalingStateForNativeState:new_state];
- RTCPeerConnection *peer_connection = peer_connection_;
- [peer_connection.delegate peerConnection:peer_connection
- didChangeSignalingState:state];
-}
-
-void PeerConnectionDelegateAdapter::OnAddStream(
- rtc::scoped_refptr<MediaStreamInterface> stream) {
- RTCMediaStream *mediaStream =
- [[RTCMediaStream alloc] initWithNativeMediaStream:stream];
- RTCPeerConnection *peer_connection = peer_connection_;
- [peer_connection.delegate peerConnection:peer_connection
- didAddStream:mediaStream];
-}
-
-void PeerConnectionDelegateAdapter::OnRemoveStream(
- rtc::scoped_refptr<MediaStreamInterface> stream) {
- RTCMediaStream *mediaStream =
- [[RTCMediaStream alloc] initWithNativeMediaStream:stream];
- RTCPeerConnection *peer_connection = peer_connection_;
- [peer_connection.delegate peerConnection:peer_connection
- didRemoveStream:mediaStream];
-}
-
-void PeerConnectionDelegateAdapter::OnDataChannel(
- rtc::scoped_refptr<DataChannelInterface> data_channel) {
- RTCDataChannel *dataChannel =
- [[RTCDataChannel alloc] initWithNativeDataChannel:data_channel];
- RTCPeerConnection *peer_connection = peer_connection_;
- [peer_connection.delegate peerConnection:peer_connection
- didOpenDataChannel:dataChannel];
-}
-
-void PeerConnectionDelegateAdapter::OnRenegotiationNeeded() {
- RTCPeerConnection *peer_connection = peer_connection_;
- [peer_connection.delegate peerConnectionShouldNegotiate:peer_connection];
-}
-
-void PeerConnectionDelegateAdapter::OnIceConnectionChange(
- PeerConnectionInterface::IceConnectionState new_state) {
- RTCIceConnectionState state =
- [[RTCPeerConnection class] iceConnectionStateForNativeState:new_state];
- RTCPeerConnection *peer_connection = peer_connection_;
- [peer_connection.delegate peerConnection:peer_connection
- didChangeIceConnectionState:state];
-}
-
-void PeerConnectionDelegateAdapter::OnIceGatheringChange(
- PeerConnectionInterface::IceGatheringState new_state) {
- RTCIceGatheringState state =
- [[RTCPeerConnection class] iceGatheringStateForNativeState:new_state];
- RTCPeerConnection *peer_connection = peer_connection_;
- [peer_connection.delegate peerConnection:peer_connection
- didChangeIceGatheringState:state];
-}
-
-void PeerConnectionDelegateAdapter::OnIceCandidate(
- const IceCandidateInterface *candidate) {
- RTCIceCandidate *iceCandidate =
- [[RTCIceCandidate alloc] initWithNativeCandidate:candidate];
- RTCPeerConnection *peer_connection = peer_connection_;
- [peer_connection.delegate peerConnection:peer_connection
- didGenerateIceCandidate:iceCandidate];
-}
-
-void PeerConnectionDelegateAdapter::OnIceCandidatesRemoved(
- const std::vector<cricket::Candidate>& candidates) {
- NSMutableArray* ice_candidates =
- [NSMutableArray arrayWithCapacity:candidates.size()];
- for (const auto& candidate : candidates) {
- std::unique_ptr<JsepIceCandidate> candidate_wrapper(
- new JsepIceCandidate(candidate.transport_name(), -1, candidate));
- RTCIceCandidate* ice_candidate = [[RTCIceCandidate alloc]
- initWithNativeCandidate:candidate_wrapper.get()];
- [ice_candidates addObject:ice_candidate];
- }
- RTCPeerConnection* peer_connection = peer_connection_;
- [peer_connection.delegate peerConnection:peer_connection
- didRemoveIceCandidates:ice_candidates];
-}
-
-} // namespace webrtc
-
-
-@implementation RTCPeerConnection {
- NSMutableArray<RTCMediaStream *> *_localStreams;
- std::unique_ptr<webrtc::PeerConnectionDelegateAdapter> _observer;
- rtc::scoped_refptr<webrtc::PeerConnectionInterface> _peerConnection;
- std::unique_ptr<webrtc::MediaConstraints> _nativeConstraints;
- BOOL _hasStartedRtcEventLog;
-}
-
-@synthesize delegate = _delegate;
-
-- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
- configuration:(RTCConfiguration *)configuration
- constraints:(RTCMediaConstraints *)constraints
- delegate:(id<RTCPeerConnectionDelegate>)delegate {
- NSParameterAssert(factory);
- std::unique_ptr<webrtc::PeerConnectionInterface::RTCConfiguration> config(
- [configuration createNativeConfiguration]);
- if (!config) {
- return nil;
- }
- if (self = [super init]) {
- _observer.reset(new webrtc::PeerConnectionDelegateAdapter(self));
- _nativeConstraints = constraints.nativeConstraints;
- CopyConstraintsIntoRtcConfiguration(_nativeConstraints.get(),
- config.get());
- _peerConnection =
- factory.nativeFactory->CreatePeerConnection(*config,
- nullptr,
- nullptr,
- _observer.get());
- if (!_peerConnection) {
- return nil;
- }
- _localStreams = [[NSMutableArray alloc] init];
- _delegate = delegate;
- }
- return self;
-}
-
-- (NSArray<RTCMediaStream *> *)localStreams {
- return [_localStreams copy];
-}
-
-- (RTCSessionDescription *)localDescription {
- const webrtc::SessionDescriptionInterface *description =
- _peerConnection->local_description();
- return description ?
- [[RTCSessionDescription alloc] initWithNativeDescription:description]
- : nil;
-}
-
-- (RTCSessionDescription *)remoteDescription {
- const webrtc::SessionDescriptionInterface *description =
- _peerConnection->remote_description();
- return description ?
- [[RTCSessionDescription alloc] initWithNativeDescription:description]
- : 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()];
-}
-
-- (BOOL)setConfiguration:(RTCConfiguration *)configuration {
- std::unique_ptr<webrtc::PeerConnectionInterface::RTCConfiguration> config(
- [configuration createNativeConfiguration]);
- if (!config) {
- return NO;
- }
- CopyConstraintsIntoRtcConfiguration(_nativeConstraints.get(),
- config.get());
- return _peerConnection->SetConfiguration(*config);
-}
-
-- (RTCConfiguration *)configuration {
- webrtc::PeerConnectionInterface::RTCConfiguration config =
- _peerConnection->GetConfiguration();
- return [[RTCConfiguration alloc] initWithNativeConfiguration:config];
-}
-
-- (void)close {
- _peerConnection->Close();
-}
-
-- (void)addIceCandidate:(RTCIceCandidate *)candidate {
- std::unique_ptr<const webrtc::IceCandidateInterface> iceCandidate(
- candidate.nativeCandidate);
- _peerConnection->AddIceCandidate(iceCandidate.get());
-}
-
-- (void)removeIceCandidates:(NSArray<RTCIceCandidate *> *)iceCandidates {
- std::vector<cricket::Candidate> candidates;
- for (RTCIceCandidate *iceCandidate in iceCandidates) {
- std::unique_ptr<const webrtc::IceCandidateInterface> candidate(
- iceCandidate.nativeCandidate);
- if (candidate) {
- candidates.push_back(candidate->candidate());
- // Need to fill the transport name from the sdp_mid.
- candidates.back().set_transport_name(candidate->sdp_mid());
- }
- }
- if (!candidates.empty()) {
- _peerConnection->RemoveIceCandidates(candidates);
- }
-}
-
-- (void)addStream:(RTCMediaStream *)stream {
- if (!_peerConnection->AddStream(stream.nativeMediaStream)) {
- RTCLogError(@"Failed to add stream: %@", stream);
- return;
- }
- [_localStreams addObject:stream];
-}
-
-- (void)removeStream:(RTCMediaStream *)stream {
- _peerConnection->RemoveStream(stream.nativeMediaStream);
- [_localStreams removeObject:stream];
-}
-
-- (void)offerForConstraints:(RTCMediaConstraints *)constraints
- completionHandler:
- (void (^)(RTCSessionDescription *sessionDescription,
- NSError *error))completionHandler {
- rtc::scoped_refptr<webrtc::CreateSessionDescriptionObserverAdapter>
- observer(new rtc::RefCountedObject
- <webrtc::CreateSessionDescriptionObserverAdapter>(completionHandler));
- _peerConnection->CreateOffer(observer, constraints.nativeConstraints.get());
-}
-
-- (void)answerForConstraints:(RTCMediaConstraints *)constraints
- completionHandler:
- (void (^)(RTCSessionDescription *sessionDescription,
- NSError *error))completionHandler {
- rtc::scoped_refptr<webrtc::CreateSessionDescriptionObserverAdapter>
- observer(new rtc::RefCountedObject
- <webrtc::CreateSessionDescriptionObserverAdapter>(completionHandler));
- _peerConnection->CreateAnswer(observer, constraints.nativeConstraints.get());
-}
-
-- (void)setLocalDescription:(RTCSessionDescription *)sdp
- completionHandler:(void (^)(NSError *error))completionHandler {
- rtc::scoped_refptr<webrtc::SetSessionDescriptionObserverAdapter> observer(
- new rtc::RefCountedObject<webrtc::SetSessionDescriptionObserverAdapter>(
- completionHandler));
- _peerConnection->SetLocalDescription(observer, sdp.nativeDescription);
-}
-
-- (void)setRemoteDescription:(RTCSessionDescription *)sdp
- completionHandler:(void (^)(NSError *error))completionHandler {
- rtc::scoped_refptr<webrtc::SetSessionDescriptionObserverAdapter> observer(
- new rtc::RefCountedObject<webrtc::SetSessionDescriptionObserverAdapter>(
- completionHandler));
- _peerConnection->SetRemoteDescription(observer, sdp.nativeDescription);
-}
-
-- (BOOL)startRtcEventLogWithFilePath:(NSString *)filePath
- maxSizeInBytes:(int64_t)maxSizeInBytes {
- RTC_DCHECK(filePath.length);
- RTC_DCHECK_GT(maxSizeInBytes, 0);
- RTC_DCHECK(!_hasStartedRtcEventLog);
- if (_hasStartedRtcEventLog) {
- RTCLogError(@"Event logging already started.");
- return NO;
- }
- int fd = open(filePath.UTF8String, O_WRONLY | O_CREAT | O_TRUNC,
- S_IRUSR | S_IWUSR);
- if (fd < 0) {
- RTCLogError(@"Error opening file: %@. Error: %d", filePath, errno);
- return NO;
- }
- _hasStartedRtcEventLog =
- _peerConnection->StartRtcEventLog(fd, maxSizeInBytes);
- return _hasStartedRtcEventLog;
-}
-
-- (void)stopRtcEventLog {
- _peerConnection->StopRtcEventLog();
- _hasStartedRtcEventLog = NO;
-}
-
-- (RTCRtpSender *)senderWithKind:(NSString *)kind
- streamId:(NSString *)streamId {
- std::string nativeKind = [NSString stdStringForString:kind];
- std::string nativeStreamId = [NSString stdStringForString:streamId];
- rtc::scoped_refptr<webrtc::RtpSenderInterface> nativeSender(
- _peerConnection->CreateSender(nativeKind, nativeStreamId));
- return nativeSender ?
- [[RTCRtpSender alloc] initWithNativeRtpSender:nativeSender]
- : nil;
-}
-
-- (NSArray<RTCRtpSender *> *)senders {
- std::vector<rtc::scoped_refptr<webrtc::RtpSenderInterface>> nativeSenders(
- _peerConnection->GetSenders());
- NSMutableArray *senders = [[NSMutableArray alloc] init];
- for (const auto &nativeSender : nativeSenders) {
- RTCRtpSender *sender =
- [[RTCRtpSender alloc] initWithNativeRtpSender:nativeSender];
- [senders addObject:sender];
- }
- return senders;
-}
-
-- (NSArray<RTCRtpReceiver *> *)receivers {
- std::vector<rtc::scoped_refptr<webrtc::RtpReceiverInterface>> nativeReceivers(
- _peerConnection->GetReceivers());
- NSMutableArray *receivers = [[NSMutableArray alloc] init];
- for (const auto &nativeReceiver : nativeReceivers) {
- RTCRtpReceiver *receiver =
- [[RTCRtpReceiver alloc] initWithNativeRtpReceiver:nativeReceiver];
- [receivers addObject:receiver];
- }
- return receivers;
-}
-
-#pragma mark - Private
-
-+ (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";
- 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 RTCIceConnectionStateCount:
- 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 RTCIceConnectionStateCount;
- }
-}
-
-+ (NSString *)stringForIceConnectionState:(RTCIceConnectionState)state {
- switch (state) {
- case RTCIceConnectionStateNew:
- return @"NEW";
- 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 RTCIceConnectionStateCount:
- return @"COUNT";
- }
-}
-
-+ (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";
- 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;
- }
-}
-
-- (rtc::scoped_refptr<webrtc::PeerConnectionInterface>)nativePeerConnection {
- return _peerConnection;
-}
-
-@end

Powered by Google App Engine
This is Rietveld 408576698