Fixed crash when PCF is destroyed before MediaSource/Track in ObjC

Bug: webrtc:9231
Change-Id: I31b86aa560f4ad230c9a94fedebebf320e0370a4
Reviewed-on: https://webrtc-review.googlesource.com/88221
Reviewed-by: Kári Helgason <kthelgason@webrtc.org>
Commit-Queue: Kári Helgason <kthelgason@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23981}

sdk/objc/Framework/Classes/PeerConnection/RTCAudioSource+Private.h

@@ -21,12 +21,12 @@
 @property(nonatomic, readonly) rtc::scoped_refptr<webrtc::AudioSourceInterface> nativeAudioSource;
 
 /** Initialize an RTCAudioSource from a native AudioSourceInterface. */
-- (instancetype)initWithNativeAudioSource:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory*)factory
-        (rtc::scoped_refptr<webrtc::AudioSourceInterface>)nativeAudioSource
+              nativeAudioSource:(rtc::scoped_refptr<webrtc::AudioSourceInterface>)nativeAudioSource
     NS_DESIGNATED_INITIALIZER;
 
-- (instancetype)initWithNativeMediaSource:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory*)factory
-                    (rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
+              nativeMediaSource:(rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
-                                     type:(RTCMediaSourceType)type NS_UNAVAILABLE;
+                           type:(RTCMediaSourceType)type NS_UNAVAILABLE;
 
 @end

sdk/objc/Framework/Classes/PeerConnection/RTCAudioSource.mm

@@ -18,19 +18,23 @@
 @synthesize volume = _volume;
 @synthesize nativeAudioSource = _nativeAudioSource;
 
-- (instancetype)initWithNativeAudioSource:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-    (rtc::scoped_refptr<webrtc::AudioSourceInterface>)nativeAudioSource {
+              nativeAudioSource:
+                  (rtc::scoped_refptr<webrtc::AudioSourceInterface>)nativeAudioSource {
+  RTC_DCHECK(factory);
   RTC_DCHECK(nativeAudioSource);
-  if (self = [super initWithNativeMediaSource:nativeAudioSource
+
-                                         type:RTCMediaSourceTypeAudio]) {
+  if (self = [super initWithFactory:factory
+                  nativeMediaSource:nativeAudioSource
+                               type:RTCMediaSourceTypeAudio]) {
     _nativeAudioSource = nativeAudioSource;
   }
   return self;
 }
 
-- (instancetype)initWithNativeMediaSource:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-    (rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
+              nativeMediaSource:(rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
-                                     type:(RTCMediaSourceType)type {
+                           type:(RTCMediaSourceType)type {
   RTC_NOTREACHED();
   return nil;
 }

sdk/objc/Framework/Classes/PeerConnection/RTCAudioTrack.mm

@@ -31,18 +31,19 @@
   std::string nativeId = [NSString stdStringForString:trackId];
   rtc::scoped_refptr<webrtc::AudioTrackInterface> track =
       factory.nativeFactory->CreateAudioTrack(nativeId, source.nativeAudioSource);
-  if (self = [self initWithNativeTrack:track type:RTCMediaStreamTrackTypeAudio]) {
+  if (self = [self initWithFactory:factory nativeTrack:track type:RTCMediaStreamTrackTypeAudio]) {
     _source = source;
   }
   return self;
 }
 
-- (instancetype)initWithNativeTrack:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-    (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack
+                    nativeTrack:(rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack
-                               type:(RTCMediaStreamTrackType)type {
+                           type:(RTCMediaStreamTrackType)type {
+  NSParameterAssert(factory);
   NSParameterAssert(nativeTrack);
   NSParameterAssert(type == RTCMediaStreamTrackTypeAudio);
-  return [super initWithNativeTrack:nativeTrack type:type];
+  return [super initWithFactory:factory nativeTrack:nativeTrack type:type];
 }
 
 
@@ -51,7 +52,8 @@
     rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
         self.nativeAudioTrack->GetSource();
     if (source) {
-      _source = [[RTCAudioSource alloc] initWithNativeAudioSource:source.get()];
+      _source =
+          [[RTCAudioSource alloc] initWithFactory:self.factory nativeAudioSource:source.get()];
     }
   }
   return _source;

sdk/objc/Framework/Classes/PeerConnection/RTCMediaSource+Private.h

@@ -14,6 +14,8 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+@class RTCPeerConnectionFactory;
+
 typedef NS_ENUM(NSInteger, RTCMediaSourceType) {
   RTCMediaSourceTypeAudio,
   RTCMediaSourceTypeVideo,
@@ -23,9 +25,9 @@ typedef NS_ENUM(NSInteger, RTCMediaSourceType) {
 
 @property(nonatomic, readonly) rtc::scoped_refptr<webrtc::MediaSourceInterface> nativeMediaSource;
 
-- (instancetype)initWithNativeMediaSource:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-                    (rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
+              nativeMediaSource:(rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
-                                     type:(RTCMediaSourceType)type NS_DESIGNATED_INITIALIZER;
+                           type:(RTCMediaSourceType)type NS_DESIGNATED_INITIALIZER;
 
 + (webrtc::MediaSourceInterface::SourceState)nativeSourceStateForState:(RTCSourceState)state;
 

sdk/objc/Framework/Classes/PeerConnection/RTCMediaSource.mm

@@ -13,16 +13,19 @@
 #include "rtc_base/checks.h"
 
 @implementation RTCMediaSource {
+  RTCPeerConnectionFactory *_factory;
   RTCMediaSourceType _type;
 }
 
 @synthesize nativeMediaSource = _nativeMediaSource;
 
-- (instancetype)initWithNativeMediaSource:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-   (rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
+              nativeMediaSource:(rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
-                                     type:(RTCMediaSourceType)type {
+                           type:(RTCMediaSourceType)type {
+  RTC_DCHECK(factory);
   RTC_DCHECK(nativeMediaSource);
   if (self = [super init]) {
+    _factory = factory;
     _nativeMediaSource = nativeMediaSource;
     _type = type;
   }

sdk/objc/Framework/Classes/PeerConnection/RTCMediaStream.mm

@@ -109,14 +109,14 @@
     for (auto &track : audioTracks) {
       RTCMediaStreamTrackType type = RTCMediaStreamTrackTypeAudio;
       RTCAudioTrack *audioTrack =
-          [[RTCAudioTrack alloc] initWithNativeTrack:track type:type];
+          [[RTCAudioTrack alloc] initWithFactory:_factory nativeTrack:track type:type];
       [_audioTracks addObject:audioTrack];
     }
 
     for (auto &track : videoTracks) {
       RTCMediaStreamTrackType type = RTCMediaStreamTrackTypeVideo;
       RTCVideoTrack *videoTrack =
-          [[RTCVideoTrack alloc] initWithNativeTrack:track type:type];
+          [[RTCVideoTrack alloc] initWithFactory:_factory nativeTrack:track type:type];
       [_videoTracks addObject:videoTrack];
     }
   }

sdk/objc/Framework/Classes/PeerConnection/RTCMediaStreamTrack+Private.h

@@ -19,8 +19,12 @@ typedef NS_ENUM(NSInteger, RTCMediaStreamTrackType) {
 
 NS_ASSUME_NONNULL_BEGIN
 
+@class RTCPeerConnectionFactory;
+
 @interface RTCMediaStreamTrack ()
 
+@property(nonatomic, readonly) RTCPeerConnectionFactory *factory;
+
 /**
  * The native MediaStreamTrackInterface passed in or created during
  * construction.
@@ -30,12 +34,12 @@ NS_ASSUME_NONNULL_BEGIN
 /**
  * Initialize an RTCMediaStreamTrack from a native MediaStreamTrackInterface.
  */
-- (instancetype)initWithNativeTrack:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-                    (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack
+                    nativeTrack:(rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack
-                               type:(RTCMediaStreamTrackType)type NS_DESIGNATED_INITIALIZER;
+                           type:(RTCMediaStreamTrackType)type NS_DESIGNATED_INITIALIZER;
 
-- (instancetype)initWithNativeTrack:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-        (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack;
+                    nativeTrack:(rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack;
 
 - (BOOL)isEqualToTrack:(RTCMediaStreamTrack *)track;
 
@@ -48,7 +52,8 @@ NS_ASSUME_NONNULL_BEGIN
 + (NSString *)stringForState:(RTCMediaStreamTrackState)state;
 
 + (RTCMediaStreamTrack *)mediaTrackForNativeTrack:
-        (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack;
+                             (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack
+                                          factory:(RTCPeerConnectionFactory *)factory;
 
 @end
 

sdk/objc/Framework/Classes/PeerConnection/RTCMediaStreamTrack.mm

@@ -20,6 +20,7 @@ NSString * const kRTCMediaStreamTrackKindVideo =
     @(webrtc::MediaStreamTrackInterface::kVideoKind);
 
 @implementation RTCMediaStreamTrack {
+  RTCPeerConnectionFactory *_factory;
   rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> _nativeTrack;
   RTCMediaStreamTrackType _type;
 }
@@ -73,29 +74,31 @@ NSString * const kRTCMediaStreamTrackKindVideo =
   return _nativeTrack;
 }
 
-- (instancetype)initWithNativeTrack:
+@synthesize factory = _factory;
-    (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack
+
-                               type:(RTCMediaStreamTrackType)type {
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
+                    nativeTrack:(rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack
+                           type:(RTCMediaStreamTrackType)type {
   NSParameterAssert(nativeTrack);
+  NSParameterAssert(factory);
   if (self = [super init]) {
+    _factory = factory;
     _nativeTrack = nativeTrack;
     _type = type;
   }
   return self;
 }
 
-- (instancetype)initWithNativeTrack:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-    (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack {
+                    nativeTrack:(rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack {
   NSParameterAssert(nativeTrack);
   if (nativeTrack->kind() ==
       std::string(webrtc::MediaStreamTrackInterface::kAudioKind)) {
-    return [self initWithNativeTrack:nativeTrack
+    return [self initWithFactory:factory nativeTrack:nativeTrack type:RTCMediaStreamTrackTypeAudio];
-                                type:RTCMediaStreamTrackTypeAudio];
   }
   if (nativeTrack->kind() ==
       std::string(webrtc::MediaStreamTrackInterface::kVideoKind)) {
-    return [self initWithNativeTrack:nativeTrack
+    return [self initWithFactory:factory nativeTrack:nativeTrack type:RTCMediaStreamTrackTypeVideo];
-                                type:RTCMediaStreamTrackTypeVideo];
   }
   return nil;
 }
@@ -137,16 +140,20 @@ NSString * const kRTCMediaStreamTrackKindVideo =
 }
 
 + (RTCMediaStreamTrack *)mediaTrackForNativeTrack:
-        (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack {
+                             (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack
+                                          factory:(RTCPeerConnectionFactory *)factory {
   NSParameterAssert(nativeTrack);
+  NSParameterAssert(factory);
   if (nativeTrack->kind() == webrtc::MediaStreamTrackInterface::kAudioKind) {
-    return
+    return [[RTCAudioTrack alloc] initWithFactory:factory
-        [[RTCAudioTrack alloc] initWithNativeTrack:nativeTrack type:RTCMediaStreamTrackTypeAudio];
+                                      nativeTrack:nativeTrack
+                                             type:RTCMediaStreamTrackTypeAudio];
   } else if (nativeTrack->kind() == webrtc::MediaStreamTrackInterface::kVideoKind) {
-    return
+    return [[RTCVideoTrack alloc] initWithFactory:factory
-        [[RTCVideoTrack alloc] initWithNativeTrack:nativeTrack type:RTCMediaStreamTrackTypeVideo];
+                                      nativeTrack:nativeTrack
+                                             type:RTCMediaStreamTrackTypeVideo];
   } else {
-    return [[RTCMediaStreamTrack alloc] initWithNativeTrack:nativeTrack];
+    return [[RTCMediaStreamTrack alloc] initWithFactory:factory nativeTrack:nativeTrack];
   }
 }
 

sdk/objc/Framework/Classes/PeerConnection/RTCPeerConnectionFactory.mm

@@ -180,7 +180,7 @@
 
   rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
       _nativeFactory->CreateAudioSource(options);
-  return [[RTCAudioSource alloc] initWithNativeAudioSource:source];
+  return [[RTCAudioSource alloc] initWithFactory:self nativeAudioSource:source];
 }
 
 - (RTCAudioTrack *)audioTrackWithTrackId:(NSString *)trackId {
@@ -196,8 +196,9 @@
 }
 
 - (RTCVideoSource *)videoSource {
-  return [[RTCVideoSource alloc] initWithSignalingThread:_signalingThread.get()
+  return [[RTCVideoSource alloc] initWithFactory:self
-                                            workerThread:_workerThread.get()];
+                                 signalingThread:_signalingThread.get()
+                                    workerThread:_workerThread.get()];
 }
 
 - (RTCVideoTrack *)videoTrackWithSource:(RTCVideoSource *)source

sdk/objc/Framework/Classes/PeerConnection/RTCRtpReceiver.mm

@@ -63,7 +63,7 @@ void RtpReceiverDelegateAdapter::OnFirstPacketReceived(
   rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> nativeTrack(
     _nativeRtpReceiver->track());
   if (nativeTrack) {
-    return [RTCMediaStreamTrack mediaTrackForNativeTrack:nativeTrack];
+    return [RTCMediaStreamTrack mediaTrackForNativeTrack:nativeTrack factory:_factory];
   }
   return nil;
 }

sdk/objc/Framework/Classes/PeerConnection/RTCRtpSender.mm

@@ -45,7 +45,7 @@
   rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> nativeTrack(
     _nativeRtpSender->track());
   if (nativeTrack) {
-    return [RTCMediaStreamTrack mediaTrackForNativeTrack:nativeTrack];
+    return [RTCMediaStreamTrack mediaTrackForNativeTrack:nativeTrack factory:_factory];
   }
   return nil;
 }

sdk/objc/Framework/Classes/PeerConnection/RTCVideoSource+Private.h

@@ -26,16 +26,18 @@ NS_ASSUME_NONNULL_BEGIN
     nativeVideoSource;
 
 /** Initialize an RTCVideoSource from a native VideoTrackSourceInterface. */
-- (instancetype)initWithNativeVideoSource:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-        (rtc::scoped_refptr<webrtc::VideoTrackSourceInterface>)nativeVideoSource
+              nativeVideoSource:
+                  (rtc::scoped_refptr<webrtc::VideoTrackSourceInterface>)nativeVideoSource
     NS_DESIGNATED_INITIALIZER;
 
-- (instancetype)initWithNativeMediaSource:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-                    (rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
+              nativeMediaSource:(rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
-                                     type:(RTCMediaSourceType)type NS_UNAVAILABLE;
+                           type:(RTCMediaSourceType)type NS_UNAVAILABLE;
 
-- (instancetype)initWithSignalingThread:(rtc::Thread *)signalingThread
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-                           workerThread:(rtc::Thread *)workerThread;
+                signalingThread:(rtc::Thread *)signalingThread
+                   workerThread:(rtc::Thread *)workerThread;
 
 @end
 

sdk/objc/Framework/Classes/PeerConnection/RTCVideoSource.mm

@@ -28,30 +28,35 @@ static webrtc::ObjCVideoTrackSource *getObjCVideoSource(
   rtc::scoped_refptr<webrtc::VideoTrackSourceInterface> _nativeVideoSource;
 }
 
-- (instancetype)initWithNativeVideoSource:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-    (rtc::scoped_refptr<webrtc::VideoTrackSourceInterface>)nativeVideoSource {
+              nativeVideoSource:
+                  (rtc::scoped_refptr<webrtc::VideoTrackSourceInterface>)nativeVideoSource {
+  RTC_DCHECK(factory);
   RTC_DCHECK(nativeVideoSource);
-  if (self = [super initWithNativeMediaSource:nativeVideoSource
+  if (self = [super initWithFactory:factory
-                                         type:RTCMediaSourceTypeVideo]) {
+                  nativeMediaSource:nativeVideoSource
+                               type:RTCMediaSourceTypeVideo]) {
     _nativeVideoSource = nativeVideoSource;
   }
   return self;
 }
 
-- (instancetype)initWithNativeMediaSource:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-    (rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
+              nativeMediaSource:(rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
-                                     type:(RTCMediaSourceType)type {
+                           type:(RTCMediaSourceType)type {
   RTC_NOTREACHED();
   return nil;
 }
 
-- (instancetype)initWithSignalingThread:(rtc::Thread *)signalingThread
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-                           workerThread:(rtc::Thread *)workerThread {
+                signalingThread:(rtc::Thread *)signalingThread
+                   workerThread:(rtc::Thread *)workerThread {
   rtc::scoped_refptr<webrtc::ObjCVideoTrackSource> objCVideoTrackSource(
       new rtc::RefCountedObject<webrtc::ObjCVideoTrackSource>());
 
-  return [self initWithNativeVideoSource:webrtc::VideoTrackSourceProxy::Create(
+  return [self initWithFactory:factory
-                                             signalingThread, workerThread, objCVideoTrackSource)];
+             nativeVideoSource:webrtc::VideoTrackSourceProxy::Create(
+                                   signalingThread, workerThread, objCVideoTrackSource)];
 }
 
 - (NSString *)description {

sdk/objc/Framework/Classes/PeerConnection/RTCVideoTrack.mm

@@ -32,18 +32,20 @@
   rtc::scoped_refptr<webrtc::VideoTrackInterface> track =
       factory.nativeFactory->CreateVideoTrack(nativeId,
                                               source.nativeVideoSource);
-  if (self = [self initWithNativeTrack:track type:RTCMediaStreamTrackTypeVideo]) {
+  if (self = [self initWithFactory:factory nativeTrack:track type:RTCMediaStreamTrackTypeVideo]) {
     _source = source;
   }
   return self;
 }
 
-- (instancetype)initWithNativeTrack:
+- (instancetype)initWithFactory:(RTCPeerConnectionFactory *)factory
-    (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeMediaTrack
+                    nativeTrack:
-                               type:(RTCMediaStreamTrackType)type {
+                        (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeMediaTrack
+                           type:(RTCMediaStreamTrackType)type {
+  NSParameterAssert(factory);
   NSParameterAssert(nativeMediaTrack);
   NSParameterAssert(type == RTCMediaStreamTrackTypeVideo);
-  if (self = [super initWithNativeTrack:nativeMediaTrack type:type]) {
+  if (self = [super initWithFactory:factory nativeTrack:nativeMediaTrack type:type]) {
     _adapters = [NSMutableArray array];
   }
   return self;
@@ -60,7 +62,8 @@
     rtc::scoped_refptr<webrtc::VideoTrackSourceInterface> source =
         self.nativeVideoTrack->GetSource();
     if (source) {
-      _source = [[RTCVideoSource alloc] initWithNativeVideoSource:source.get()];
+      _source =
+          [[RTCVideoSource alloc] initWithFactory:self.factory nativeVideoSource:source.get()];
     }
   }
   return _source;

sdk/objc/Framework/UnitTests/RTCPeerConnectionFactory_xctest.m

@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#import <WebRTC/RTCAudioSource.h>
 #import <WebRTC/RTCConfiguration.h>
 #import <WebRTC/RTCDataChannel.h>
 #import <WebRTC/RTCDataChannelConfiguration.h>
@@ -18,6 +19,7 @@
 #import <WebRTC/RTCRtpReceiver.h>
 #import <WebRTC/RTCRtpSender.h>
 #import <WebRTC/RTCRtpTransceiver.h>
+#import <WebRTC/RTCVideoSource.h>
 
 #import <XCTest/XCTest.h>
 
@@ -193,6 +195,74 @@
   XCTAssertTrue(true, "Expect test does not crash");
 }
 
+- (void)testAudioSourceLifetime {
+  @autoreleasepool {
+    RTCPeerConnectionFactory *factory;
+    RTCAudioSource *audioSource;
+
+    @autoreleasepool {
+      factory = [[RTCPeerConnectionFactory alloc] init];
+      audioSource = [factory audioSourceWithConstraints:nil];
+      XCTAssertNotNil(audioSource);
+      factory = nil;
+    }
+    audioSource = nil;
+  }
+
+  XCTAssertTrue(true, "Expect test does not crash");
+}
+
+- (void)testVideoSourceLifetime {
+  @autoreleasepool {
+    RTCPeerConnectionFactory *factory;
+    RTCVideoSource *videoSource;
+
+    @autoreleasepool {
+      factory = [[RTCPeerConnectionFactory alloc] init];
+      videoSource = [factory videoSource];
+      XCTAssertNotNil(videoSource);
+      factory = nil;
+    }
+    videoSource = nil;
+  }
+
+  XCTAssertTrue(true, "Expect test does not crash");
+}
+
+- (void)testAudioTrackLifetime {
+  @autoreleasepool {
+    RTCPeerConnectionFactory *factory;
+    RTCAudioTrack *audioTrack;
+
+    @autoreleasepool {
+      factory = [[RTCPeerConnectionFactory alloc] init];
+      audioTrack = [factory audioTrackWithTrackId:@"audioTrack"];
+      XCTAssertNotNil(audioTrack);
+      factory = nil;
+    }
+    audioTrack = nil;
+  }
+
+  XCTAssertTrue(true, "Expect test does not crash");
+}
+
+- (void)testVideoTrackLifetime {
+  @autoreleasepool {
+    RTCPeerConnectionFactory *factory;
+    RTCVideoTrack *videoTrack;
+
+    @autoreleasepool {
+      factory = [[RTCPeerConnectionFactory alloc] init];
+      videoTrack = [factory videoTrackWithSource:[factory videoSource] trackId:@"videoTrack"];
+      XCTAssertNotNil(videoTrack);
+      factory = nil;
+    }
+    videoTrack = nil;
+  }
+
+  XCTAssertTrue(true, "Expect test does not crash");
+}
+
 - (bool)negotiatePeerConnection:(RTCPeerConnection *)pc1
              withPeerConnection:(RTCPeerConnection *)pc2
              negotiationTimeout:(NSTimeInterval)timeout {