ObjC style fix for injectable video codecs

webrtc/sdk/objc/Framework/Classes/PeerConnection/RTCVideoCodecH264.mm

 /*
  *  Copyright 2017 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.
  */
 
@@ skipping 18 matching lines @@
 
 bool IsHighProfileEnabled() {
   return webrtc::field_trial::IsEnabled(kHighProfileExperiment);
 }
 
 // H264 specific settings.
 @implementation RTCCodecSpecificInfoH264
 
 @synthesize packetizationMode = _packetizationMode;
 
-- (webrtc::CodecSpecificInfo)toCpp {
+- (webrtc::CodecSpecificInfo)nativeCodecSpecificInfo {
   webrtc::CodecSpecificInfo codecSpecificInfo;
   codecSpecificInfo.codecType = webrtc::kVideoCodecH264;
   codecSpecificInfo.codec_name = "H264";
   codecSpecificInfo.codecSpecific.H264.packetization_mode =
       (webrtc::H264PacketizationMode)_packetizationMode;
 
   return codecSpecificInfo;
 }
 
 @end
 
 namespace {
 
 class H264VideoToolboxEncodeCompleteCallback : public webrtc::EncodedImageCallback {
  public:
   Result OnEncodedImage(const webrtc::EncodedImage &encoded_image,
                         const webrtc::CodecSpecificInfo *codec_specific_info,
                         const webrtc::RTPFragmentationHeader *fragmentation) {
     RTCEncodedImage *image = [[RTCEncodedImage alloc] initWithNativeEncodedImage:encoded_image];
 
     RTCCodecSpecificInfoH264 *info = [[RTCCodecSpecificInfoH264 alloc] init];
     info.packetizationMode =
         (RTCH264PacketizationMode)codec_specific_info->codecSpecific.H264.packetization_mode;
 
     RTCRtpFragmentationHeader *header =
-        [[RTCRtpFragmentationHeader alloc] initWithFragmentationHeader:fragmentation];
+        [[RTCRtpFragmentationHeader alloc] initWithNativeFragmentationHeader:fragmentation];
 
     callback(image, info, header);
     return Result(Result::OK, 0);
   }
 
   RTCVideoEncoderCallback callback;
 };
 
 class H264VideoToolboxDecodeCompleteCallback : public webrtc::DecodedImageCallback {
  public:
@@ skipping 22 matching lines @@
 }  // namespace
 
 // Encoder.
 @implementation RTCVideoEncoderH264 {
   webrtc::H264VideoToolboxEncoder *_videoToolboxEncoder;
   H264VideoToolboxEncodeCompleteCallback *_toolboxCallback;
 }
 
 - (instancetype)initWithCodecInfo:(RTCVideoCodecInfo *)codecInfo {
   if (self = [super init]) {
-    cricket::VideoCodec codec = [codecInfo toCpp];
+    cricket::VideoCodec codec = [codecInfo nativeVideoCodec];
     _videoToolboxEncoder = new webrtc::H264VideoToolboxEncoder(codec);
   }
   return self;
 }
 
 - (void)setCallback:(RTCVideoEncoderCallback)callback {
   if (!_toolboxCallback) _toolboxCallback = new H264VideoToolboxEncodeCompleteCallback();
   _toolboxCallback->callback = callback;
   _videoToolboxEncoder->RegisterEncodeCompleteCallback(_toolboxCallback);
 }
 
 - (void)destroy {
   delete _videoToolboxEncoder;
   _videoToolboxEncoder = nullptr;
   delete _toolboxCallback;
   _toolboxCallback = nullptr;
 }
 
 -(void)dealloc {
   // Make sure C++ objects have been properly cleaned up before this
   // is dealloc'd.
   RTC_DCHECK(!_videoToolboxEncoder);
   RTC_DCHECK(!_toolboxCallback);
 }
 
 - (NSInteger)startEncodeWithSettings:(RTCVideoEncoderSettings *)settings
                        numberOfCores:(int)numberOfCores {
-  std::unique_ptr<webrtc::VideoCodec> codecSettings = [settings toCpp];
+  std::unique_ptr<webrtc::VideoCodec> codecSettings = [settings createNativeVideoEncoderSettings];
   return _videoToolboxEncoder->InitEncode(
       codecSettings.release(), numberOfCores, kDefaultPayloadSize);
 }
 
 - (NSInteger)releaseEncoder {
   return _videoToolboxEncoder->Release();
 }
 
 - (NSInteger)encode:(RTCVideoFrame *)frame
     codecSpecificInfo:(id<RTCCodecSpecificInfo>)info
            frameTypes:(NSArray<NSNumber *> *)frameTypes {
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> frameBuffer =
       new rtc::RefCountedObject<webrtc::ObjCFrameBuffer>(frame.buffer);
   webrtc::VideoFrame videoFrame(frameBuffer,
                                 (webrtc::VideoRotation)frame.rotation,
                                 frame.timeStampNs / rtc::kNumNanosecsPerMicrosec);
   videoFrame.set_timestamp(frame.timeStamp);
 
   // Handle types than can be converted into one of webrtc::CodecSpecificInfo's hard coded cases.
   webrtc::CodecSpecificInfo codecSpecificInfo;
   if ([info isKindOfClass:[RTCCodecSpecificInfoH264 class]]) {
-    codecSpecificInfo = [(RTCCodecSpecificInfoH264 *)info toCpp];
+    codecSpecificInfo = [(RTCCodecSpecificInfoH264 *)info nativeCodecSpecificInfo];
   }
 
   std::vector<webrtc::FrameType> nativeFrameTypes;
   for (NSNumber *frameType in frameTypes) {
     RTCFrameType rtcFrameType = (RTCFrameType)frameType.unsignedIntegerValue;
     nativeFrameTypes.push_back((webrtc::FrameType)rtcFrameType);
   }
 
   return _videoToolboxEncoder->Encode(videoFrame, &codecSpecificInfo, &nativeFrameTypes);
 }
@@ skipping 13 matching lines @@
 - (instancetype)init {
   if (self = [super init]) {
     cricket::VideoCodec codec(cricket::kH264CodecName);
     _videoToolboxDecoder = new webrtc::H264VideoToolboxDecoder();
   }
   return self;
 }
 
 - (NSInteger)startDecodeWithSettings:(RTCVideoEncoderSettings *)settings
                        numberOfCores:(int)numberOfCores {
-  std::unique_ptr<webrtc::VideoCodec> codecSettings = [settings toCpp];
+  std::unique_ptr<webrtc::VideoCodec> codecSettings = [settings createNativeVideoEncoderSettings];
   return _videoToolboxDecoder->InitDecode(codecSettings.release(), numberOfCores);
 }
 
 - (void)setCallback:(RTCVideoDecoderCallback)callback {
   if (!_toolboxCallback) _toolboxCallback = new H264VideoToolboxDecodeCompleteCallback();
   _toolboxCallback->callback = callback;
   _videoToolboxDecoder->RegisterDecodeCompleteCallback(_toolboxCallback);
 }
 
 - (NSInteger)releaseDecoder {
@@ skipping 12 matching lines @@
   // is dealloc'd.
   RTC_DCHECK(!_videoToolboxDecoder);
   RTC_DCHECK(!_toolboxCallback);
 }
 
 - (NSInteger)decode:(RTCEncodedImage *)encodedImage
           missingFrames:(BOOL)missingFrames
     fragmentationHeader:(RTCRtpFragmentationHeader *)fragmentationHeader
       codecSpecificInfo:(__nullable id<RTCCodecSpecificInfo>)info
            renderTimeMs:(int64_t)renderTimeMs {
-  webrtc::EncodedImage image = [encodedImage toCpp];
+  webrtc::EncodedImage image = [encodedImage nativeEncodedImage];
 
   // Handle types than can be converted into one of webrtc::CodecSpecificInfo's hard coded cases.
   webrtc::CodecSpecificInfo codecSpecificInfo;
   if ([info isKindOfClass:[RTCCodecSpecificInfoH264 class]]) {
-    codecSpecificInfo = [(RTCCodecSpecificInfoH264 *)info toCpp];
+    codecSpecificInfo = [(RTCCodecSpecificInfoH264 *)info nativeCodecSpecificInfo];
   }
 
-  std::unique_ptr<webrtc::RTPFragmentationHeader> header = [fragmentationHeader toCpp];
+  std::unique_ptr<webrtc::RTPFragmentationHeader> header =
+      [fragmentationHeader createNativeFragmentationHeader];
 
   return _videoToolboxDecoder->Decode(
       image, missingFrames, header.release(), &codecSpecificInfo, renderTimeMs);
 }
 
 @end
 
 // Encoder factory.
 @implementation RTCVideoEncoderFactoryH264
 
@@ skipping 40 matching lines @@
 - (id<RTCVideoDecoder>)createDecoder:(RTCVideoCodecInfo *)info {
   return [[RTCVideoDecoderH264 alloc] init];
 }
 
 - (NSArray<RTCVideoCodecInfo *> *)supportedCodecs {
   NSString *codecName = [NSString stringWithUTF8String:cricket::kH264CodecName];
   return @[ [[RTCVideoCodecInfo alloc] initWithPayload:0 name:codecName parameters:@{}] ];
 }
 
 @end