Prefix enums with RTC_OBJC_TYPE macro (#171)

Continued from webrtc-sdk/webrtc#100 also prefix
enums.
I think this shouldn't break compiling.

Author: hiroshihorie

sdk/objc/api/logging/RTCCallbackLogger.h

@@ -17,15 +17,15 @@ NS_ASSUME_NONNULL_BEGIN
 
 typedef void (^RTCCallbackLoggerMessageHandler)(NSString *message);
 typedef void (^RTCCallbackLoggerMessageAndSeverityHandler)(NSString *message,
-                                                           RTCLoggingSeverity severity);
+                                                           RTC_OBJC_TYPE(RTCLoggingSeverity) severity);
 
 // This class intercepts WebRTC logs and forwards them to a registered block.
 // This class is not threadsafe.
 RTC_OBJC_EXPORT
 @interface RTC_OBJC_TYPE (RTCCallbackLogger) : NSObject
 
 // The severity level to capture. The default is kRTCLoggingSeverityInfo.
-@property(nonatomic, assign) RTCLoggingSeverity severity;
+@property(nonatomic, assign) RTC_OBJC_TYPE(RTCLoggingSeverity) severity;
 
 // The callback handler will be called on the same thread that does the
 // logging, so if the logging callback can be slow it may be a good idea

sdk/objc/api/logging/RTCCallbackLogger.mm

@@ -53,24 +53,24 @@ void OnLogMessage(const std::string& message, rtc::LoggingSeverity severity) ove
 
   void OnLogMessage(absl::string_view message, rtc::LoggingSeverity severity) override {
     if (callback_handler_) {
-      RTCLoggingSeverity loggingSeverity = NativeSeverityToObjcSeverity(severity);
+      RTC_OBJC_TYPE(RTCLoggingSeverity) loggingSeverity = NativeSeverityToObjcSeverity(severity);
       callback_handler_([NSString stringForAbslStringView:message], loggingSeverity);
     }
   }
 
  private:
-  static RTCLoggingSeverity NativeSeverityToObjcSeverity(rtc::LoggingSeverity severity) {
+  static RTC_OBJC_TYPE(RTCLoggingSeverity) NativeSeverityToObjcSeverity(rtc::LoggingSeverity severity) {
     switch (severity) {
       case rtc::LS_VERBOSE:
-        return RTCLoggingSeverityVerbose;
+        return RTC_OBJC_TYPE(RTCLoggingSeverityVerbose);
       case rtc::LS_INFO:
-        return RTCLoggingSeverityInfo;
+        return RTC_OBJC_TYPE(RTCLoggingSeverityInfo);
       case rtc::LS_WARNING:
-        return RTCLoggingSeverityWarning;
+        return RTC_OBJC_TYPE(RTCLoggingSeverityWarning);
       case rtc::LS_ERROR:
-        return RTCLoggingSeverityError;
+        return RTC_OBJC_TYPE(RTCLoggingSeverityError);
       case rtc::LS_NONE:
-        return RTCLoggingSeverityNone;
+        return RTC_OBJC_TYPE(RTCLoggingSeverityNone);
     }
   }
 
@@ -89,7 +89,7 @@ @implementation RTC_OBJC_TYPE (RTCCallbackLogger) {
 - (instancetype)init {
   self = [super init];
   if (self != nil) {
-    _severity = RTCLoggingSeverityInfo;
+    _severity = RTC_OBJC_TYPE(RTCLoggingSeverityInfo);
   }
   return self;
 }
@@ -135,15 +135,15 @@ - (void)stop {
 
 - (rtc::LoggingSeverity)rtcSeverity {
   switch (_severity) {
-    case RTCLoggingSeverityVerbose:
+    case RTC_OBJC_TYPE(RTCLoggingSeverityVerbose):
       return rtc::LS_VERBOSE;
-    case RTCLoggingSeverityInfo:
+    case RTC_OBJC_TYPE(RTCLoggingSeverityInfo):
       return rtc::LS_INFO;
-    case RTCLoggingSeverityWarning:
+    case RTC_OBJC_TYPE(RTCLoggingSeverityWarning):
       return rtc::LS_WARNING;
-    case RTCLoggingSeverityError:
+    case RTC_OBJC_TYPE(RTCLoggingSeverityError):
       return rtc::LS_ERROR;
-    case RTCLoggingSeverityNone:
+    case RTC_OBJC_TYPE(RTCLoggingSeverityNone):
       return rtc::LS_NONE;
   }
 }

sdk/objc/api/peerconnection/RTCAudioSource+Private.h

@@ -29,6 +29,6 @@
 
 - (instancetype)initWithFactory:(RTC_OBJC_TYPE(RTCPeerConnectionFactory) *)factory
               nativeMediaSource:(rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
-                           type:(RTCMediaSourceType)type NS_UNAVAILABLE;
+                           type:(RTC_OBJC_TYPE(RTCMediaSourceType))type NS_UNAVAILABLE;
 
 @end

sdk/objc/api/peerconnection/RTCAudioSource.mm

@@ -26,15 +26,15 @@ - (instancetype)initWithFactory:(RTC_OBJC_TYPE(RTCPeerConnectionFactory) *)facto
 
   if (self = [super initWithFactory:factory
                   nativeMediaSource:nativeAudioSource
-                               type:RTCMediaSourceTypeAudio]) {
+                               type:RTC_OBJC_TYPE(RTCMediaSourceTypeAudio)]) {
     _nativeAudioSource = nativeAudioSource;
   }
   return self;
 }
 
 - (instancetype)initWithFactory:(RTC_OBJC_TYPE(RTCPeerConnectionFactory) *)factory
               nativeMediaSource:(rtc::scoped_refptr<webrtc::MediaSourceInterface>)nativeMediaSource
-                           type:(RTCMediaSourceType)type {
+                           type:(RTC_OBJC_TYPE(RTCMediaSourceType))type {
   RTC_DCHECK_NOTREACHED();
   return nil;
 }

sdk/objc/api/peerconnection/RTCAudioTrack.mm

@@ -39,7 +39,7 @@ - (instancetype)initWithFactory:(RTC_OBJC_TYPE(RTCPeerConnectionFactory) *)facto
   std::string nativeId = [NSString stdStringForString:trackId];
   rtc::scoped_refptr<webrtc::AudioTrackInterface> track =
       factory.nativeFactory->CreateAudioTrack(nativeId, source.nativeAudioSource.get());
-  if (self = [self initWithFactory:factory nativeTrack:track type:RTCMediaStreamTrackTypeAudio]) {
+  if (self = [self initWithFactory:factory nativeTrack:track type:RTC_OBJC_TYPE(RTCMediaStreamTrackTypeAudio)]) {
     _source = source;
   }
 
@@ -48,10 +48,10 @@ - (instancetype)initWithFactory:(RTC_OBJC_TYPE(RTCPeerConnectionFactory) *)facto
 
 - (instancetype)initWithFactory:(RTC_OBJC_TYPE(RTCPeerConnectionFactory) *)factory
                     nativeTrack:(rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)nativeTrack
-                           type:(RTCMediaStreamTrackType)type {
+                           type:(RTC_OBJC_TYPE(RTCMediaStreamTrackType))type {
   NSParameterAssert(factory);
   NSParameterAssert(nativeTrack);
-  NSParameterAssert(type == RTCMediaStreamTrackTypeAudio);
+  NSParameterAssert(type == RTC_OBJC_TYPE(RTCMediaStreamTrackTypeAudio));
   if (self = [super initWithFactory:factory nativeTrack:nativeTrack type:type]) {
     _adapters = [NSMutableArray array];
     _signalingThread = factory.signalingThread;

sdk/objc/api/peerconnection/RTCConfiguration+Private.h

@@ -18,52 +18,52 @@ NS_ASSUME_NONNULL_BEGIN
 ()
 
     + (webrtc::PeerConnectionInterface::IceTransportsType)nativeTransportsTypeForTransportPolicy
-    : (RTCIceTransportPolicy)policy;
+    : (RTC_OBJC_TYPE(RTCIceTransportPolicy))policy;
 
-+ (RTCIceTransportPolicy)transportPolicyForTransportsType:
++ (RTC_OBJC_TYPE(RTCIceTransportPolicy))transportPolicyForTransportsType:
     (webrtc::PeerConnectionInterface::IceTransportsType)nativeType;
 
-+ (NSString *)stringForTransportPolicy:(RTCIceTransportPolicy)policy;
++ (NSString *)stringForTransportPolicy:(RTC_OBJC_TYPE(RTCIceTransportPolicy))policy;
 
 + (webrtc::PeerConnectionInterface::BundlePolicy)nativeBundlePolicyForPolicy:
-    (RTCBundlePolicy)policy;
+    (RTC_OBJC_TYPE(RTCBundlePolicy))policy;
 
-+ (RTCBundlePolicy)bundlePolicyForNativePolicy:
++ (RTC_OBJC_TYPE(RTCBundlePolicy))bundlePolicyForNativePolicy:
     (webrtc::PeerConnectionInterface::BundlePolicy)nativePolicy;
 
-+ (NSString *)stringForBundlePolicy:(RTCBundlePolicy)policy;
++ (NSString *)stringForBundlePolicy:(RTC_OBJC_TYPE(RTCBundlePolicy))policy;
 
 + (webrtc::PeerConnectionInterface::RtcpMuxPolicy)nativeRtcpMuxPolicyForPolicy:
-    (RTCRtcpMuxPolicy)policy;
+    (RTC_OBJC_TYPE(RTCRtcpMuxPolicy))policy;
 
-+ (RTCRtcpMuxPolicy)rtcpMuxPolicyForNativePolicy:
++ (RTC_OBJC_TYPE(RTCRtcpMuxPolicy))rtcpMuxPolicyForNativePolicy:
     (webrtc::PeerConnectionInterface::RtcpMuxPolicy)nativePolicy;
 
-+ (NSString *)stringForRtcpMuxPolicy:(RTCRtcpMuxPolicy)policy;
++ (NSString *)stringForRtcpMuxPolicy:(RTC_OBJC_TYPE(RTCRtcpMuxPolicy))policy;
 
 + (webrtc::PeerConnectionInterface::TcpCandidatePolicy)nativeTcpCandidatePolicyForPolicy:
-    (RTCTcpCandidatePolicy)policy;
+    (RTC_OBJC_TYPE(RTCTcpCandidatePolicy))policy;
 
-+ (RTCTcpCandidatePolicy)tcpCandidatePolicyForNativePolicy:
++ (RTC_OBJC_TYPE(RTCTcpCandidatePolicy))tcpCandidatePolicyForNativePolicy:
     (webrtc::PeerConnectionInterface::TcpCandidatePolicy)nativePolicy;
 
-+ (NSString *)stringForTcpCandidatePolicy:(RTCTcpCandidatePolicy)policy;
++ (NSString *)stringForTcpCandidatePolicy:(RTC_OBJC_TYPE(RTCTcpCandidatePolicy))policy;
 
 + (webrtc::PeerConnectionInterface::CandidateNetworkPolicy)nativeCandidateNetworkPolicyForPolicy:
-    (RTCCandidateNetworkPolicy)policy;
+    (RTC_OBJC_TYPE(RTCCandidateNetworkPolicy))policy;
 
-+ (RTCCandidateNetworkPolicy)candidateNetworkPolicyForNativePolicy:
++ (RTC_OBJC_TYPE(RTCCandidateNetworkPolicy))candidateNetworkPolicyForNativePolicy:
     (webrtc::PeerConnectionInterface::CandidateNetworkPolicy)nativePolicy;
 
-+ (NSString *)stringForCandidateNetworkPolicy:(RTCCandidateNetworkPolicy)policy;
++ (NSString *)stringForCandidateNetworkPolicy:(RTC_OBJC_TYPE(RTCCandidateNetworkPolicy))policy;
 
-+ (rtc::KeyType)nativeEncryptionKeyTypeForKeyType:(RTCEncryptionKeyType)keyType;
++ (rtc::KeyType)nativeEncryptionKeyTypeForKeyType:(RTC_OBJC_TYPE(RTCEncryptionKeyType))keyType;
 
-+ (webrtc::SdpSemantics)nativeSdpSemanticsForSdpSemantics:(RTCSdpSemantics)sdpSemantics;
++ (webrtc::SdpSemantics)nativeSdpSemanticsForSdpSemantics:(RTC_OBJC_TYPE(RTCSdpSemantics))sdpSemantics;
 
-+ (RTCSdpSemantics)sdpSemanticsForNativeSdpSemantics:(webrtc::SdpSemantics)sdpSemantics;
++ (RTC_OBJC_TYPE(RTCSdpSemantics))sdpSemanticsForNativeSdpSemantics:(webrtc::SdpSemantics)sdpSemantics;
 
-+ (NSString *)stringForSdpSemantics:(RTCSdpSemantics)sdpSemantics;
++ (NSString *)stringForSdpSemantics:(RTC_OBJC_TYPE(RTCSdpSemantics))sdpSemantics;
 
 /**
  * RTCConfiguration struct representation of this RTCConfiguration.

sdk/objc/api/peerconnection/RTCConfiguration.h

@@ -20,52 +20,55 @@
  * Represents the ice transport policy. This exposes the same states in C++,
  * which include one more state than what exists in the W3C spec.
  */
-typedef NS_ENUM(NSInteger, RTCIceTransportPolicy) {
-  RTCIceTransportPolicyNone,
-  RTCIceTransportPolicyRelay,
-  RTCIceTransportPolicyNoHost,
-  RTCIceTransportPolicyAll
+typedef NS_ENUM(NSInteger, RTC_OBJC_TYPE(RTCIceTransportPolicy)) {
+  RTC_OBJC_TYPE(RTCIceTransportPolicyNone),
+  RTC_OBJC_TYPE(RTCIceTransportPolicyRelay),
+  RTC_OBJC_TYPE(RTCIceTransportPolicyNoHost),
+  RTC_OBJC_TYPE(RTCIceTransportPolicyAll)
 };
 
 /** Represents the bundle policy. */
-typedef NS_ENUM(NSInteger, RTCBundlePolicy) {
-  RTCBundlePolicyBalanced,
-  RTCBundlePolicyMaxCompat,
-  RTCBundlePolicyMaxBundle
+typedef NS_ENUM(NSInteger, RTC_OBJC_TYPE(RTCBundlePolicy)) {
+  RTC_OBJC_TYPE(RTCBundlePolicyBalanced),
+  RTC_OBJC_TYPE(RTCBundlePolicyMaxCompat),
+  RTC_OBJC_TYPE(RTCBundlePolicyMaxBundle)
 };
 
 /** Represents the rtcp mux policy. */
-typedef NS_ENUM(NSInteger, RTCRtcpMuxPolicy) { RTCRtcpMuxPolicyNegotiate, RTCRtcpMuxPolicyRequire };
+typedef NS_ENUM(NSInteger, RTC_OBJC_TYPE(RTCRtcpMuxPolicy)) {
+  RTC_OBJC_TYPE(RTCRtcpMuxPolicyNegotiate),
+  RTC_OBJC_TYPE(RTCRtcpMuxPolicyRequire)
+};
 
 /** Represents the tcp candidate policy. */
-typedef NS_ENUM(NSInteger, RTCTcpCandidatePolicy) {
-  RTCTcpCandidatePolicyEnabled,
-  RTCTcpCandidatePolicyDisabled
+typedef NS_ENUM(NSInteger, RTC_OBJC_TYPE(RTCTcpCandidatePolicy)) {
+  RTC_OBJC_TYPE(RTCTcpCandidatePolicyEnabled),
+  RTC_OBJC_TYPE(RTCTcpCandidatePolicyDisabled)
 };
 
 /** Represents the candidate network policy. */
-typedef NS_ENUM(NSInteger, RTCCandidateNetworkPolicy) {
-  RTCCandidateNetworkPolicyAll,
-  RTCCandidateNetworkPolicyLowCost
+typedef NS_ENUM(NSInteger, RTC_OBJC_TYPE(RTCCandidateNetworkPolicy)) {
+  RTC_OBJC_TYPE(RTCCandidateNetworkPolicyAll),
+  RTC_OBJC_TYPE(RTCCandidateNetworkPolicyLowCost)
 };
 
 /** Represents the continual gathering policy. */
-typedef NS_ENUM(NSInteger, RTCContinualGatheringPolicy) {
-  RTCContinualGatheringPolicyGatherOnce,
-  RTCContinualGatheringPolicyGatherContinually
+typedef NS_ENUM(NSInteger, RTC_OBJC_TYPE(RTCContinualGatheringPolicy)) {
+  RTC_OBJC_TYPE(RTCContinualGatheringPolicyGatherOnce),
+  RTC_OBJC_TYPE(RTCContinualGatheringPolicyGatherContinually)
 };
 
 /** Represents the encryption key type. */
-typedef NS_ENUM(NSInteger, RTCEncryptionKeyType) {
-  RTCEncryptionKeyTypeRSA,
-  RTCEncryptionKeyTypeECDSA,
+typedef NS_ENUM(NSInteger, RTC_OBJC_TYPE(RTCEncryptionKeyType)) {
+  RTC_OBJC_TYPE(RTCEncryptionKeyTypeRSA),
+  RTC_OBJC_TYPE(RTCEncryptionKeyTypeECDSA),
 };
 
 /** Represents the chosen SDP semantics for the RTCPeerConnection. */
-typedef NS_ENUM(NSInteger, RTCSdpSemantics) {
+typedef NS_ENUM(NSInteger, RTC_OBJC_TYPE(RTCSdpSemantics)) {
   // TODO(https://crbug.com/webrtc/13528): Remove support for Plan B.
-  RTCSdpSemanticsPlanB,
-  RTCSdpSemanticsUnifiedPlan,
+  RTC_OBJC_TYPE(RTCSdpSemanticsPlanB),
+  RTC_OBJC_TYPE(RTCSdpSemanticsUnifiedPlan),
 };
 
 NS_ASSUME_NONNULL_BEGIN
@@ -86,16 +89,16 @@ RTC_OBJC_EXPORT
 
 /** Which candidates the ICE agent is allowed to use. The W3C calls it
  * `iceTransportPolicy`, while in C++ it is called `type`. */
-@property(nonatomic, assign) RTCIceTransportPolicy iceTransportPolicy;
+@property(nonatomic, assign) RTC_OBJC_TYPE(RTCIceTransportPolicy) iceTransportPolicy;
 
 /** The media-bundling policy to use when gathering ICE candidates. */
-@property(nonatomic, assign) RTCBundlePolicy bundlePolicy;
+@property(nonatomic, assign) RTC_OBJC_TYPE(RTCBundlePolicy) bundlePolicy;
 
 /** The rtcp-mux policy to use when gathering ICE candidates. */
-@property(nonatomic, assign) RTCRtcpMuxPolicy rtcpMuxPolicy;
-@property(nonatomic, assign) RTCTcpCandidatePolicy tcpCandidatePolicy;
-@property(nonatomic, assign) RTCCandidateNetworkPolicy candidateNetworkPolicy;
-@property(nonatomic, assign) RTCContinualGatheringPolicy continualGatheringPolicy;
+@property(nonatomic, assign) RTC_OBJC_TYPE(RTCRtcpMuxPolicy) rtcpMuxPolicy;
+@property(nonatomic, assign) RTC_OBJC_TYPE(RTCTcpCandidatePolicy) tcpCandidatePolicy;
+@property(nonatomic, assign) RTC_OBJC_TYPE(RTCCandidateNetworkPolicy) candidateNetworkPolicy;
+@property(nonatomic, assign) RTC_OBJC_TYPE(RTCContinualGatheringPolicy) continualGatheringPolicy;
 
 /** If set to YES, don't gather IPv6 ICE candidates on Wi-Fi.
  *  Only intended to be used on specific devices. Certain phones disable IPv6
@@ -125,7 +128,7 @@ RTC_OBJC_EXPORT
 @property(nonatomic, assign) int iceBackupCandidatePairPingInterval;
 
 /** Key type used to generate SSL identity. Default is ECDSA. */
-@property(nonatomic, assign) RTCEncryptionKeyType keyType;
+@property(nonatomic, assign) RTC_OBJC_TYPE(RTCEncryptionKeyType) keyType;
 
 /** ICE candidate pool size as defined in JSEP. Default is 0. */
 @property(nonatomic, assign) int iceCandidatePoolSize;
@@ -176,7 +179,7 @@ RTC_OBJC_EXPORT
  * the section. This will also cause RTCPeerConnection to ignore all but the
  * first m= section of the same media type.
  */
-@property(nonatomic, assign) RTCSdpSemantics sdpSemantics;
+@property(nonatomic, assign) RTC_OBJC_TYPE(RTCSdpSemantics) sdpSemantics;
 
 /** Actively reset the SRTP parameters when the DTLS transports underneath are
  *  changed after offer/answer negotiation. This is only intended to be a