Android: Update convenience macro defining JNI-accessible methods

webrtc/sdk/android/src/jni/pc/peerconnectionfactory_jni.cc

 /*
  *  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 29 matching lines @@
 // instead of "video_jni.cc", which doesn't bring in the video-specific
 // dependencies.
 
 // Field trials initialization string
 static char* field_trials_init_string = nullptr;
 
 // Set in PeerConnectionFactory_initializeAndroidGlobals().
 static bool factory_static_initialized = false;
 static bool video_hw_acceleration_enabled = true;
 
-JOW(jlong, PeerConnectionFactory_nativeCreateObserver)
-(JNIEnv* jni, jclass, jobject j_observer) {
+JNI_FUNCTION_DECLARATION(jlong,
+                         PeerConnectionFactory_nativeCreateObserver,
+                         JNIEnv* jni,
+                         jclass,
+                         jobject j_observer) {
   return (jlong) new PeerConnectionObserverJni(jni, j_observer);
 }
 
-JOW(void, PeerConnectionFactory_nativeInitializeAndroidGlobals)
-(JNIEnv* jni, jclass, jobject context, jboolean video_hw_acceleration) {
+JNI_FUNCTION_DECLARATION(void,
+                         PeerConnectionFactory_nativeInitializeAndroidGlobals,
+                         JNIEnv* jni,
+                         jclass,
+                         jobject context,
+                         jboolean video_hw_acceleration) {
   video_hw_acceleration_enabled = video_hw_acceleration;
   if (!factory_static_initialized) {
     webrtc::JVM::Initialize(GetJVM());
     factory_static_initialized = true;
   }
 }
 
-JOW(void, PeerConnectionFactory_initializeFieldTrials)
-(JNIEnv* jni, jclass, jstring j_trials_init_string) {
+JNI_FUNCTION_DECLARATION(void,
+                         PeerConnectionFactory_initializeFieldTrials,
+                         JNIEnv* jni,
+                         jclass,
+                         jstring j_trials_init_string) {
   field_trials_init_string = NULL;
   if (j_trials_init_string != NULL) {
     const char* init_string =
         jni->GetStringUTFChars(j_trials_init_string, NULL);
     int init_string_length = jni->GetStringUTFLength(j_trials_init_string);
     field_trials_init_string = new char[init_string_length + 1];
     rtc::strcpyn(field_trials_init_string, init_string_length + 1, init_string);
     jni->ReleaseStringUTFChars(j_trials_init_string, init_string);
     LOG(LS_INFO) << "initializeFieldTrials: " << field_trials_init_string;
   }
   webrtc::field_trial::InitFieldTrialsFromString(field_trials_init_string);
 }
 
-JOW(void, PeerConnectionFactory_initializeInternalTracer)(JNIEnv* jni, jclass) {
+JNI_FUNCTION_DECLARATION(void,
+                         PeerConnectionFactory_initializeInternalTracer,
+                         JNIEnv* jni,
+                         jclass) {
   rtc::tracing::SetupInternalTracer();
 }
 
-JOW(jstring, PeerConnectionFactory_nativeFieldTrialsFindFullName)
-(JNIEnv* jni, jclass, jstring j_name) {
+JNI_FUNCTION_DECLARATION(jstring,
+                         PeerConnectionFactory_nativeFieldTrialsFindFullName,
+                         JNIEnv* jni,
+                         jclass,
+                         jstring j_name) {
   return JavaStringFromStdString(
       jni, webrtc::field_trial::FindFullName(JavaToStdString(jni, j_name)));
 }
 
-JOW(jboolean, PeerConnectionFactory_startInternalTracingCapture)
-(JNIEnv* jni, jclass, jstring j_event_tracing_filename) {
+JNI_FUNCTION_DECLARATION(jboolean,
+                         PeerConnectionFactory_startInternalTracingCapture,
+                         JNIEnv* jni,
+                         jclass,
+                         jstring j_event_tracing_filename) {
   if (!j_event_tracing_filename)
     return false;
 
   const char* init_string =
       jni->GetStringUTFChars(j_event_tracing_filename, NULL);
   LOG(LS_INFO) << "Starting internal tracing to: " << init_string;
   bool ret = rtc::tracing::StartInternalCapture(init_string);
   jni->ReleaseStringUTFChars(j_event_tracing_filename, init_string);
   return ret;
 }
 
-JOW(void, PeerConnectionFactory_stopInternalTracingCapture)
-(JNIEnv* jni, jclass) {
+JNI_FUNCTION_DECLARATION(void,
+                         PeerConnectionFactory_stopInternalTracingCapture,
+                         JNIEnv* jni,
+                         jclass) {
   rtc::tracing::StopInternalCapture();
 }
 
-JOW(void, PeerConnectionFactory_shutdownInternalTracer)(JNIEnv* jni, jclass) {
+JNI_FUNCTION_DECLARATION(void,
+                         PeerConnectionFactory_shutdownInternalTracer,
+                         JNIEnv* jni,
+                         jclass) {
   rtc::tracing::ShutdownInternalTracer();
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnectionFactory)
-(JNIEnv* jni,
- jclass,
- jobject joptions,
- jobject jencoder_factory,
- jobject jdecoder_factory) {
+JNI_FUNCTION_DECLARATION(
+    jlong,
+    PeerConnectionFactory_nativeCreatePeerConnectionFactory,
+    JNIEnv* jni,
+    jclass,
+    jobject joptions,
+    jobject jencoder_factory,
+    jobject jdecoder_factory) {
   // talk/ assumes pretty widely that the current Thread is ThreadManager'd, but
   // ThreadManager only WrapCurrentThread()s the thread where it is first
   // created.  Since the semantics around when auto-wrapping happens in
   // webrtc/rtc_base/ are convoluted, we simply wrap here to avoid having to
   // think about ramifications of auto-wrapping there.
   rtc::ThreadManager::Instance()->WrapCurrentThread();
   webrtc::Trace::CreateTrace();
 
   std::unique_ptr<rtc::Thread> network_thread =
       rtc::Thread::CreateWithSocketServer();
@@ skipping 56 matching lines @@
     factory->SetOptions(options);
   }
   OwnedFactoryAndThreads* owned_factory = new OwnedFactoryAndThreads(
       std::move(network_thread), std::move(worker_thread),
       std::move(signaling_thread), video_encoder_factory, video_decoder_factory,
       network_monitor_factory, factory.release());
   owned_factory->InvokeJavaCallbacksOnFactoryThreads();
   return jlongFromPointer(owned_factory);
 }
 
-JOW(void, PeerConnectionFactory_nativeFreeFactory)(JNIEnv*, jclass, jlong j_p) {
+JNI_FUNCTION_DECLARATION(void,
+                         PeerConnectionFactory_nativeFreeFactory,
+                         JNIEnv*,
+                         jclass,
+                         jlong j_p) {
   delete reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
   if (field_trials_init_string) {
     webrtc::field_trial::InitFieldTrialsFromString(NULL);
     delete field_trials_init_string;
     field_trials_init_string = NULL;
   }
   webrtc::Trace::ReturnTrace();
 }
 
-JOW(void, PeerConnectionFactory_nativeThreadsCallbacks)
-(JNIEnv*, jclass, jlong j_p) {
+JNI_FUNCTION_DECLARATION(void,
+                         PeerConnectionFactory_nativeThreadsCallbacks,
+                         JNIEnv*,
+                         jclass,
+                         jlong j_p) {
   OwnedFactoryAndThreads* factory =
       reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
   factory->InvokeJavaCallbacksOnFactoryThreads();
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreateLocalMediaStream)
-(JNIEnv* jni, jclass, jlong native_factory, jstring label) {
+JNI_FUNCTION_DECLARATION(jlong,
+                         PeerConnectionFactory_nativeCreateLocalMediaStream,
+                         JNIEnv* jni,
+                         jclass,
+                         jlong native_factory,
+                         jstring label) {
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
       factory->CreateLocalMediaStream(JavaToStdString(jni, label)));
   return (jlong)stream.release();
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreateAudioSource)
-(JNIEnv* jni, jclass, jlong native_factory, jobject j_constraints) {
+JNI_FUNCTION_DECLARATION(jlong,
+                         PeerConnectionFactory_nativeCreateAudioSource,
+                         JNIEnv* jni,
+                         jclass,
+                         jlong native_factory,
+                         jobject j_constraints) {
   std::unique_ptr<MediaConstraintsJni> constraints(
       new MediaConstraintsJni(jni, j_constraints));
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   cricket::AudioOptions options;
   CopyConstraintsIntoAudioOptions(constraints.get(), &options);
   rtc::scoped_refptr<webrtc::AudioSourceInterface> source(
       factory->CreateAudioSource(options));
   return (jlong)source.release();
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreateAudioTrack)
-(JNIEnv* jni, jclass, jlong native_factory, jstring id, jlong native_source) {
+JNI_FUNCTION_DECLARATION(jlong,
+                         PeerConnectionFactory_nativeCreateAudioTrack,
+                         JNIEnv* jni,
+                         jclass,
+                         jlong native_factory,
+                         jstring id,
+                         jlong native_source) {
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   rtc::scoped_refptr<webrtc::AudioTrackInterface> track(
       factory->CreateAudioTrack(
           JavaToStdString(jni, id),
           reinterpret_cast<webrtc::AudioSourceInterface*>(native_source)));
   return (jlong)track.release();
 }
 
-JOW(jboolean, PeerConnectionFactory_nativeStartAecDump)
-(JNIEnv* jni,
- jclass,
- jlong native_factory,
- jint file,
- jint filesize_limit_bytes) {
+JNI_FUNCTION_DECLARATION(jboolean,
+                         PeerConnectionFactory_nativeStartAecDump,
+                         JNIEnv* jni,
+                         jclass,
+                         jlong native_factory,
+                         jint file,
+                         jint filesize_limit_bytes) {
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   return factory->StartAecDump(file, filesize_limit_bytes);
 }
 
-JOW(void, PeerConnectionFactory_nativeStopAecDump)
-(JNIEnv* jni, jclass, jlong native_factory) {
+JNI_FUNCTION_DECLARATION(void,
+                         PeerConnectionFactory_nativeStopAecDump,
+                         JNIEnv* jni,
+                         jclass,
+                         jlong native_factory) {
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   factory->StopAecDump();
 }
 
-JOW(void, PeerConnectionFactory_nativeSetOptions)
-(JNIEnv* jni, jclass, jlong native_factory, jobject options) {
+JNI_FUNCTION_DECLARATION(void,
+                         PeerConnectionFactory_nativeSetOptions,
+                         JNIEnv* jni,
+                         jclass,
+                         jlong native_factory,
+                         jobject options) {
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   webrtc::PeerConnectionFactoryInterface::Options options_to_set =
       JavaToNativePeerConnectionFactoryOptions(jni, options);
   factory->SetOptions(options_to_set);
 
   if (options_to_set.disable_network_monitor) {
     OwnedFactoryAndThreads* owner =
         reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
     if (owner->network_monitor_factory()) {
       rtc::NetworkMonitorFactory::ReleaseFactory(
           owner->network_monitor_factory());
       owner->clear_network_monitor_factory();
     }
   }
 }
 
-JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnection)
-(JNIEnv* jni,
- jclass,
- jlong factory,
- jobject j_rtc_config,
- jobject j_constraints,
- jlong observer_p) {
+JNI_FUNCTION_DECLARATION(jlong,
+                         PeerConnectionFactory_nativeCreatePeerConnection,
+                         JNIEnv* jni,
+                         jclass,
+                         jlong factory,
+                         jobject j_rtc_config,
+                         jobject j_constraints,
+                         jlong observer_p) {
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> f(
       reinterpret_cast<webrtc::PeerConnectionFactoryInterface*>(
           factoryFromJava(factory)));
 
   webrtc::PeerConnectionInterface::RTCConfiguration rtc_config(
       webrtc::PeerConnectionInterface::RTCConfigurationType::kAggressive);
   JavaToNativeRTCConfiguration(jni, j_rtc_config, &rtc_config);
 
   jclass j_rtc_config_class = GetObjectClass(jni, j_rtc_config);
   jfieldID j_key_type_id = GetFieldID(jni, j_rtc_config_class, "keyType",
@@ skipping 16 matching lines @@
   PeerConnectionObserverJni* observer =
       reinterpret_cast<PeerConnectionObserverJni*>(observer_p);
   observer->SetConstraints(new MediaConstraintsJni(jni, j_constraints));
   CopyConstraintsIntoRtcConfiguration(observer->constraints(), &rtc_config);
   rtc::scoped_refptr<webrtc::PeerConnectionInterface> pc(
       f->CreatePeerConnection(rtc_config, nullptr, nullptr, observer));
   return (jlong)pc.release();
 }
 
 }  // namespace webrtc_jni