Android: Remove static thread references from PeerconnectionFactory

This CL prepares for adding stack trace capability to the native part of
the Android PeerConnectionFactory code. The main blocker this CL removes
is the static printStackTrace() function. We need this function to be
non-static since the C++ counterpart of PCF is non-static. This Cl also
performs various other cleanups in surrounding code.

This CL:
 * Removes static thread references from PeerconnectionFactory and turns
   them into non-static member variables.
 * Adds a non-static alternative to
   PeerconnectionFactory.printStackTraces().
 * Removes the rtc::Thread::Invoke() calls, and turns them into
   asynchronous posts.
 * Consolidates the two different Java PCF ctors into one, so that there
   is one shared path used by both native API and Java API.

Bug: webrtc:10168
Change-Id: I05dbf5b17069d4a115d9adafc25faa121f23b945
Reviewed-on: https://webrtc-review.googlesource.com/c/115961
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Tommi <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26329}

sdk/android/api/org/webrtc/PeerConnectionFactory.java

@@ -29,11 +29,17 @@ public class PeerConnectionFactory {
   private static final String TAG = "PeerConnectionFactory";
   private static final String VIDEO_CAPTURER_THREAD_NAME = "VideoCapturerThread";
 
-  private long nativeFactory;
   private static volatile boolean internalTracerInitialized;
-  @Nullable private static Thread networkThread;
+
-  @Nullable private static Thread workerThread;
+  // Remove these once deprecated static printStackTrace() is gone.
-  @Nullable private static Thread signalingThread;
+  @Nullable private static Thread staticNetworkThread;
+  @Nullable private static Thread staticWorkerThread;
+  @Nullable private static Thread staticSignalingThread;
+
+  private long nativeFactory;
+  @Nullable private volatile Thread networkThread;
+  @Nullable private volatile Thread workerThread;
+  @Nullable private volatile Thread signalingThread;
 
   public static class InitializationOptions {
     final Context applicationContext;
@@ -218,9 +224,17 @@ public class PeerConnectionFactory {
     }
 
     public PeerConnectionFactory createPeerConnectionFactory() {
-      return new PeerConnectionFactory(options, audioDeviceModule, audioEncoderFactoryFactory,
+      checkInitializeHasBeenCalled();
-          audioDecoderFactoryFactory, videoEncoderFactory, videoDecoderFactory,
+      return nativeCreatePeerConnectionFactory(ContextUtils.getApplicationContext(), options,
-          audioProcessingFactory, fecControllerFactoryFactory, mediaTransportFactoryFactory);
+          audioDeviceModule == null ? 0 : audioDeviceModule.getNativeAudioDeviceModulePointer(),
+          audioEncoderFactoryFactory.createNativeAudioEncoderFactory(),
+          audioDecoderFactoryFactory.createNativeAudioDecoderFactory(), videoEncoderFactory,
+          videoDecoderFactory,
+          audioProcessingFactory == null ? 0 : audioProcessingFactory.createNative(),
+          fecControllerFactoryFactory == null ? 0 : fecControllerFactoryFactory.createNative(),
+          mediaTransportFactoryFactory == null
+              ? 0
+              : mediaTransportFactoryFactory.createNativeMediaTransportFactory());
     }
   }
 
@@ -253,7 +267,7 @@ public class PeerConnectionFactory {
     }
   }
 
-  private void checkInitializeHasBeenCalled() {
+  private static void checkInitializeHasBeenCalled() {
     if (!NativeLibrary.isLoaded() || ContextUtils.getApplicationContext() == null) {
       throw new IllegalStateException(
           "PeerConnectionFactory.initialize was not called before creating a "
@@ -298,30 +312,6 @@ public class PeerConnectionFactory {
     nativeStopInternalTracingCapture();
   }
 
-  private PeerConnectionFactory(Options options, @Nullable AudioDeviceModule audioDeviceModule,
-      AudioEncoderFactoryFactory audioEncoderFactoryFactory,
-      AudioDecoderFactoryFactory audioDecoderFactoryFactory,
-      @Nullable VideoEncoderFactory videoEncoderFactory,
-      @Nullable VideoDecoderFactory videoDecoderFactory,
-      @Nullable AudioProcessingFactory audioProcessingFactory,
-      @Nullable FecControllerFactoryFactoryInterface fecControllerFactoryFactory,
-      @Nullable MediaTransportFactoryFactory mediaTransportFactoryFactory) {
-    checkInitializeHasBeenCalled();
-    nativeFactory = nativeCreatePeerConnectionFactory(ContextUtils.getApplicationContext(), options,
-        audioDeviceModule == null ? 0 : audioDeviceModule.getNativeAudioDeviceModulePointer(),
-        audioEncoderFactoryFactory.createNativeAudioEncoderFactory(),
-        audioDecoderFactoryFactory.createNativeAudioDecoderFactory(), videoEncoderFactory,
-        videoDecoderFactory,
-        audioProcessingFactory == null ? 0 : audioProcessingFactory.createNative(),
-        fecControllerFactoryFactory == null ? 0 : fecControllerFactoryFactory.createNative(),
-        mediaTransportFactoryFactory == null
-            ? 0
-            : mediaTransportFactoryFactory.createNativeMediaTransportFactory());
-    if (nativeFactory == 0) {
-      throw new RuntimeException("Failed to initialize PeerConnectionFactory!");
-    }
-  }
-
   @CalledByNative
   PeerConnectionFactory(long nativeFactory) {
     checkInitializeHasBeenCalled();
@@ -463,11 +453,6 @@ public class PeerConnectionFactory {
     nativeFactory = 0;
   }
 
-  public void threadsCallbacks() {
-    checkPeerConnectionFactoryExists();
-    nativeInvokeThreadsCallbacks(nativeFactory);
-  }
-
   /** Returns a pointer to the native webrtc::PeerConnectionFactoryInterface. */
   public long getNativePeerConnectionFactory() {
     checkPeerConnectionFactoryExists();
@@ -498,27 +483,43 @@ public class PeerConnectionFactory {
     }
   }
 
+  /** Deprecated, use non-static version instead. */
+  @Deprecated
   public static void printStackTraces() {
-    printStackTrace(networkThread, "Network thread");
+    printStackTrace(staticNetworkThread, "Network thread");
-    printStackTrace(workerThread, "Worker thread");
+    printStackTrace(staticWorkerThread, "Worker thread");
+    printStackTrace(staticSignalingThread, "Signaling thread");
+  }
+
+  /**
+   * Print the Java stack traces for the critical threads used by PeerConnectionFactory, namely;
+   * signaling thread, worker thread, and network thread. If printNativeStackTraces is true, also
+   * attempt to print the C++ stack traces for these threads.
+   */
+  public void printInternalStackTraces(boolean printNativeStackTraces) {
     printStackTrace(signalingThread, "Signaling thread");
+    printStackTrace(workerThread, "Worker thread");
+    printStackTrace(networkThread, "Network thread");
   }
 
   @CalledByNative
-  private static void onNetworkThreadReady() {
+  private void onNetworkThreadReady() {
     networkThread = Thread.currentThread();
+    staticNetworkThread = networkThread;
     Logging.d(TAG, "onNetworkThreadReady");
   }
 
   @CalledByNative
-  private static void onWorkerThreadReady() {
+  private void onWorkerThreadReady() {
     workerThread = Thread.currentThread();
+    staticWorkerThread = workerThread;
     Logging.d(TAG, "onWorkerThreadReady");
   }
 
   @CalledByNative
-  private static void onSignalingThreadReady() {
+  private void onSignalingThreadReady() {
     signalingThread = Thread.currentThread();
+    staticSignalingThread = signalingThread;
     Logging.d(TAG, "onSignalingThreadReady");
   }
 
@@ -534,10 +535,11 @@ public class PeerConnectionFactory {
   private static native boolean nativeStartInternalTracingCapture(String tracingFilename);
   private static native void nativeStopInternalTracingCapture();
 
-  private static native long nativeCreatePeerConnectionFactory(Context context, Options options,
+  private static native PeerConnectionFactory nativeCreatePeerConnectionFactory(Context context,
-      long nativeAudioDeviceModule, long audioEncoderFactory, long audioDecoderFactory,
+      Options options, long nativeAudioDeviceModule, long audioEncoderFactory,
-      VideoEncoderFactory encoderFactory, VideoDecoderFactory decoderFactory,
+      long audioDecoderFactory, VideoEncoderFactory encoderFactory,
-      long nativeAudioProcessor, long nativeFecControllerFactory, long mediaTransportFactory);
+      VideoDecoderFactory decoderFactory, long nativeAudioProcessor,
+      long nativeFecControllerFactory, long mediaTransportFactory);
 
   private static native long nativeCreatePeerConnection(long factory,
       PeerConnection.RTCConfiguration rtcConfig, MediaConstraints constraints, long nativeObserver,
@@ -552,7 +554,6 @@ public class PeerConnectionFactory {
   private static native boolean nativeStartAecDump(
       long factory, int file_descriptor, int filesize_limit_bytes);
   private static native void nativeStopAecDump(long factory);
-  private static native void nativeInvokeThreadsCallbacks(long factory);
   private static native void nativeFreeFactory(long factory);
   private static native long nativeGetNativePeerConnectionFactory(long factory);
   private static native void nativeInjectLoggable(JNILogging jniLogging, int severity);

sdk/android/src/jni/pc/owned_factory_and_threads.cc

@@ -11,21 +11,16 @@
 #include "sdk/android/src/jni/pc/owned_factory_and_threads.h"
 
 #include "sdk/android/src/jni/jni_helpers.h"
-#include "sdk/android/src/jni/pc/peer_connection_factory.h"
 
 namespace webrtc {
 namespace jni {
 
-PeerConnectionFactoryInterface* factoryFromJava(jlong j_p) {
-  return reinterpret_cast<OwnedFactoryAndThreads*>(j_p)->factory();
-}
-
 OwnedFactoryAndThreads::OwnedFactoryAndThreads(
     std::unique_ptr<rtc::Thread> network_thread,
     std::unique_ptr<rtc::Thread> worker_thread,
     std::unique_ptr<rtc::Thread> signaling_thread,
     rtc::NetworkMonitorFactory* network_monitor_factory,
-    PeerConnectionFactoryInterface* factory)
+    const rtc::scoped_refptr<PeerConnectionFactoryInterface>& factory)
     : network_thread_(std::move(network_thread)),
       worker_thread_(std::move(worker_thread)),
       signaling_thread_(std::move(signaling_thread)),
@@ -33,21 +28,10 @@ OwnedFactoryAndThreads::OwnedFactoryAndThreads(
       factory_(factory) {}
 
 OwnedFactoryAndThreads::~OwnedFactoryAndThreads() {
-  factory_->Release();
   if (network_monitor_factory_ != nullptr) {
     rtc::NetworkMonitorFactory::ReleaseFactory(network_monitor_factory_);
   }
 }
 
-void OwnedFactoryAndThreads::InvokeJavaCallbacksOnFactoryThreads() {
-  RTC_LOG(LS_INFO) << "InvokeJavaCallbacksOnFactoryThreads.";
-  network_thread_->Invoke<void>(RTC_FROM_HERE,
-                                &PeerConnectionFactoryNetworkThreadReady);
-  worker_thread_->Invoke<void>(RTC_FROM_HERE,
-                               &PeerConnectionFactoryWorkerThreadReady);
-  signaling_thread_->Invoke<void>(RTC_FROM_HERE,
-                                  &PeerConnectionFactorySignalingThreadReady);
-}
-
 }  // namespace jni
 }  // namespace webrtc

sdk/android/src/jni/pc/owned_factory_and_threads.h

@@ -21,8 +21,6 @@
 namespace webrtc {
 namespace jni {
 
-PeerConnectionFactoryInterface* factoryFromJava(jlong j_p);
-
 // Helper struct for working around the fact that CreatePeerConnectionFactory()
 // comes in two flavors: either entirely automagical (constructing its own
 // threads and deleting them on teardown, but no external codec factory support)
@@ -31,15 +29,16 @@ PeerConnectionFactoryInterface* factoryFromJava(jlong j_p);
 // single thing for Java to hold and eventually free.
 class OwnedFactoryAndThreads {
  public:
-  OwnedFactoryAndThreads(std::unique_ptr<rtc::Thread> network_thread,
+  OwnedFactoryAndThreads(
-                         std::unique_ptr<rtc::Thread> worker_thread,
+      std::unique_ptr<rtc::Thread> network_thread,
-                         std::unique_ptr<rtc::Thread> signaling_thread,
+      std::unique_ptr<rtc::Thread> worker_thread,
-                         rtc::NetworkMonitorFactory* network_monitor_factory,
+      std::unique_ptr<rtc::Thread> signaling_thread,
-                         PeerConnectionFactoryInterface* factory);
+      rtc::NetworkMonitorFactory* network_monitor_factory,
+      const rtc::scoped_refptr<PeerConnectionFactoryInterface>& factory);
 
   ~OwnedFactoryAndThreads();
 
-  PeerConnectionFactoryInterface* factory() { return factory_; }
+  PeerConnectionFactoryInterface* factory() { return factory_.get(); }
   rtc::Thread* network_thread() { return network_thread_.get(); }
   rtc::Thread* signaling_thread() { return signaling_thread_.get(); }
   rtc::Thread* worker_thread() { return worker_thread_.get(); }
@@ -47,14 +46,13 @@ class OwnedFactoryAndThreads {
     return network_monitor_factory_;
   }
   void clear_network_monitor_factory() { network_monitor_factory_ = nullptr; }
-  void InvokeJavaCallbacksOnFactoryThreads();
 
  private:
   const std::unique_ptr<rtc::Thread> network_thread_;
   const std::unique_ptr<rtc::Thread> worker_thread_;
   const std::unique_ptr<rtc::Thread> signaling_thread_;
   rtc::NetworkMonitorFactory* network_monitor_factory_;
-  PeerConnectionFactoryInterface* factory_;  // Const after ctor except dtor.
+  const rtc::scoped_refptr<PeerConnectionFactoryInterface> factory_;
 };
 
 }  // namespace jni

sdk/android/src/jni/pc/peer_connection_factory.cc

@@ -43,21 +43,70 @@ namespace jni {
 
 namespace {
 
-PeerConnectionFactoryInterface::Options
+// Take ownership of the jlong reference and cast it into an rtc::scoped_refptr.
+template <typename T>
+rtc::scoped_refptr<T> TakeOwnershipOfRefPtr(jlong j_pointer) {
+  T* ptr = reinterpret_cast<T*>(j_pointer);
+  rtc::scoped_refptr<T> refptr;
+  refptr.swap(&ptr);
+  return refptr;
+}
+
+// Take ownership of the jlong reference and cast it into a std::unique_ptr.
+template <typename T>
+std::unique_ptr<T> TakeOwnershipOfUniquePtr(jlong native_pointer) {
+  return std::unique_ptr<T>(reinterpret_cast<T*>(native_pointer));
+}
+
+typedef void (*JavaMethodPointer)(JNIEnv*, const JavaRef<jobject>&);
+
+// Post a message on the given queue that will call the Java method on the given
+// Java object.
+void PostJavaCallback(JNIEnv* env,
+                      rtc::MessageQueue* queue,
+                      const rtc::Location& posted_from,
+                      const JavaRef<jobject>& j_object,
+                      JavaMethodPointer java_method_pointer) {
+  // One-off message handler that calls the Java method on the specified Java
+  // object before deleting itself.
+  class JavaAsyncCallback : public rtc::MessageHandler {
+   public:
+    JavaAsyncCallback(JNIEnv* env,
+                      const JavaRef<jobject>& j_object,
+                      JavaMethodPointer java_method_pointer)
+        : j_object_(env, j_object), java_method_pointer_(java_method_pointer) {}
+
+    void OnMessage(rtc::Message*) override {
+      java_method_pointer_(AttachCurrentThreadIfNeeded(), j_object_);
+      // The message has been delivered, clean up after ourself.
+      delete this;
+    }
+
+   private:
+    ScopedJavaGlobalRef<jobject> j_object_;
+    JavaMethodPointer java_method_pointer_;
+  };
+
+  queue->Post(posted_from,
+              new JavaAsyncCallback(env, j_object, java_method_pointer));
+}
+
+absl::optional<PeerConnectionFactoryInterface::Options>
 JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni,
-                                         const JavaRef<jobject>& options) {
+                                         const JavaRef<jobject>& j_options) {
-  int network_ignore_mask = Java_Options_getNetworkIgnoreMask(jni, options);
+  if (j_options.is_null())
-  bool disable_encryption = Java_Options_getDisableEncryption(jni, options);
+    return absl::nullopt;
-  bool disable_network_monitor =
-      Java_Options_getDisableNetworkMonitor(jni, options);
 
   PeerConnectionFactoryInterface::Options native_options;
 
   // This doesn't necessarily match the c++ version of this struct; feel free
   // to add more parameters as necessary.
-  native_options.network_ignore_mask = network_ignore_mask;
+  native_options.network_ignore_mask =
-  native_options.disable_encryption = disable_encryption;
+      Java_Options_getNetworkIgnoreMask(jni, j_options);
-  native_options.disable_network_monitor = disable_network_monitor;
+  native_options.disable_encryption =
+      Java_Options_getDisableEncryption(jni, j_options);
+  native_options.disable_network_monitor =
+      Java_Options_getDisableNetworkMonitor(jni, j_options);
 
   return native_options;
 }
@@ -76,6 +125,34 @@ StaticObjectContainer& GetStaticObjects() {
   return *static_objects;
 }
 
+ScopedJavaLocalRef<jobject> NativeToScopedJavaPeerConnectionFactory(
+    JNIEnv* env,
+    rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf,
+    std::unique_ptr<rtc::Thread> network_thread,
+    std::unique_ptr<rtc::Thread> worker_thread,
+    std::unique_ptr<rtc::Thread> signaling_thread,
+    rtc::NetworkMonitorFactory* network_monitor_factory) {
+  OwnedFactoryAndThreads* owned_factory = new OwnedFactoryAndThreads(
+      std::move(network_thread), std::move(worker_thread),
+      std::move(signaling_thread), network_monitor_factory, pcf);
+
+  ScopedJavaLocalRef<jobject> j_pcf = Java_PeerConnectionFactory_Constructor(
+      env, NativeToJavaPointer(owned_factory));
+
+  PostJavaCallback(env, owned_factory->network_thread(), RTC_FROM_HERE, j_pcf,
+                   &Java_PeerConnectionFactory_onNetworkThreadReady);
+  PostJavaCallback(env, owned_factory->worker_thread(), RTC_FROM_HERE, j_pcf,
+                   &Java_PeerConnectionFactory_onWorkerThreadReady);
+  PostJavaCallback(env, owned_factory->signaling_thread(), RTC_FROM_HERE, j_pcf,
+                   &Java_PeerConnectionFactory_onSignalingThreadReady);
+
+  return j_pcf;
+}
+
+PeerConnectionFactoryInterface* PeerConnectionFactoryFromJava(jlong j_p) {
+  return reinterpret_cast<OwnedFactoryAndThreads*>(j_p)->factory();
+}
+
 }  // namespace
 
 // Note: Some of the video-specific PeerConnectionFactory methods are
@@ -87,23 +164,6 @@ StaticObjectContainer& GetStaticObjects() {
 // Set in PeerConnectionFactory_initializeAndroidGlobals().
 static bool factory_static_initialized = false;
 
-void PeerConnectionFactoryNetworkThreadReady() {
-  RTC_LOG(LS_INFO) << "Network thread JavaCallback";
-  JNIEnv* env = AttachCurrentThreadIfNeeded();
-  Java_PeerConnectionFactory_onNetworkThreadReady(env);
-}
-
-void PeerConnectionFactoryWorkerThreadReady() {
-  RTC_LOG(LS_INFO) << "Worker thread JavaCallback";
-  JNIEnv* env = AttachCurrentThreadIfNeeded();
-  Java_PeerConnectionFactory_onWorkerThreadReady(env);
-}
-
-void PeerConnectionFactorySignalingThreadReady() {
-  RTC_LOG(LS_INFO) << "Signaling thread JavaCallback";
-  JNIEnv* env = AttachCurrentThreadIfNeeded();
-  Java_PeerConnectionFactory_onSignalingThreadReady(env);
-}
 
 jobject NativeToJavaPeerConnectionFactory(
     JNIEnv* jni,
@@ -112,13 +172,9 @@ jobject NativeToJavaPeerConnectionFactory(
     std::unique_ptr<rtc::Thread> worker_thread,
     std::unique_ptr<rtc::Thread> signaling_thread,
     rtc::NetworkMonitorFactory* network_monitor_factory) {
-  jni::OwnedFactoryAndThreads* owned_factory = new jni::OwnedFactoryAndThreads(
+  return NativeToScopedJavaPeerConnectionFactory(
-      std::move(network_thread), std::move(worker_thread),
+             jni, pcf, std::move(network_thread), std::move(worker_thread),
-      std::move(signaling_thread), network_monitor_factory, pcf.release());
+             std::move(signaling_thread), network_monitor_factory)
-  owned_factory->InvokeJavaCallbacksOnFactoryThreads();
-
-  return Java_PeerConnectionFactory_Constructor(
-             jni, NativeToJavaPointer(owned_factory))
       .Release();
 }
 
@@ -183,7 +239,7 @@ static void JNI_PeerConnectionFactory_ShutdownInternalTracer(JNIEnv* jni) {
 // Following parameters are optional:
 // |audio_device_module|, |jencoder_factory|, |jdecoder_factory|,
 // |audio_processor|, |media_transport_factory|, |fec_controller_factory|.
-jlong CreatePeerConnectionFactoryForJava(
+ScopedJavaLocalRef<jobject> CreatePeerConnectionFactoryForJava(
     JNIEnv* jni,
     const JavaParamRef<jobject>& jcontext,
     const JavaParamRef<jobject>& joptions,
@@ -217,15 +273,12 @@ jlong CreatePeerConnectionFactoryForJava(
 
   rtc::NetworkMonitorFactory* network_monitor_factory = nullptr;
 
-  PeerConnectionFactoryInterface::Options options;
+  const absl::optional<PeerConnectionFactoryInterface::Options> options =
-  bool has_options = !joptions.is_null();
+      JavaToNativePeerConnectionFactoryOptions(jni, joptions);
-  if (has_options) {
-    options = JavaToNativePeerConnectionFactoryOptions(jni, joptions);
-  }
 
   // Do not create network_monitor_factory only if the options are
   // provided and disable_network_monitor therein is set to true.
-  if (!(has_options && options.disable_network_monitor)) {
+  if (!(options && options->disable_network_monitor)) {
     network_monitor_factory = new AndroidNetworkMonitorFactory();
     rtc::NetworkMonitorFactory::SetFactory(network_monitor_factory);
   }
@@ -259,17 +312,16 @@ jlong CreatePeerConnectionFactoryForJava(
                      << "WebRTC/libjingle init likely failed on this device";
   // TODO(honghaiz): Maybe put the options as the argument of
   // CreatePeerConnectionFactory.
-  if (has_options) {
+  if (options)
-    factory->SetOptions(options);
+    factory->SetOptions(*options);
-  }
+
-  OwnedFactoryAndThreads* owned_factory = new OwnedFactoryAndThreads(
+  return NativeToScopedJavaPeerConnectionFactory(
-      std::move(network_thread), std::move(worker_thread),
+      jni, factory, std::move(network_thread), std::move(worker_thread),
-      std::move(signaling_thread), network_monitor_factory, factory.release());
+      std::move(signaling_thread), network_monitor_factory);
-  owned_factory->InvokeJavaCallbacksOnFactoryThreads();
-  return jlongFromPointer(owned_factory);
 }
 
-static jlong JNI_PeerConnectionFactory_CreatePeerConnectionFactory(
+static ScopedJavaLocalRef<jobject>
+JNI_PeerConnectionFactory_CreatePeerConnectionFactory(
     JNIEnv* jni,
     const JavaParamRef<jobject>& jcontext,
     const JavaParamRef<jobject>& joptions,
@@ -283,30 +335,17 @@ static jlong JNI_PeerConnectionFactory_CreatePeerConnectionFactory(
     jlong native_media_transport_factory) {
   rtc::scoped_refptr<AudioProcessing> audio_processor =
       reinterpret_cast<AudioProcessing*>(native_audio_processor);
-  AudioEncoderFactory* audio_encoder_factory_ptr =
-      reinterpret_cast<AudioEncoderFactory*>(native_audio_encoder_factory);
-  rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory(
-      audio_encoder_factory_ptr);
-  // Release the caller's reference count.
-  audio_encoder_factory->Release();
-  AudioDecoderFactory* audio_decoder_factory_ptr =
-      reinterpret_cast<AudioDecoderFactory*>(native_audio_decoder_factory);
-  rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory(
-      audio_decoder_factory_ptr);
-  // Release the caller's reference count.
-  audio_decoder_factory->Release();
-  std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory(
-      reinterpret_cast<FecControllerFactoryInterface*>(
-          native_fec_controller_factory));
-  std::unique_ptr<MediaTransportFactory> media_transport_factory(
-      reinterpret_cast<MediaTransportFactory*>(native_media_transport_factory));
   return CreatePeerConnectionFactoryForJava(
       jni, jcontext, joptions,
       reinterpret_cast<AudioDeviceModule*>(native_audio_device_module),
-      audio_encoder_factory, audio_decoder_factory, jencoder_factory,
+      TakeOwnershipOfRefPtr<AudioEncoderFactory>(native_audio_encoder_factory),
-      jdecoder_factory,
+      TakeOwnershipOfRefPtr<AudioDecoderFactory>(native_audio_decoder_factory),
+      jencoder_factory, jdecoder_factory,
       audio_processor ? audio_processor : CreateAudioProcessing(),
-      std::move(fec_controller_factory), std::move(media_transport_factory));
+      TakeOwnershipOfUniquePtr<FecControllerFactoryInterface>(
+          native_fec_controller_factory),
+      TakeOwnershipOfUniquePtr<MediaTransportFactory>(
+          native_media_transport_factory));
 }
 
 static void JNI_PeerConnectionFactory_FreeFactory(JNIEnv*,
@@ -316,22 +355,13 @@ static void JNI_PeerConnectionFactory_FreeFactory(JNIEnv*,
   GetStaticObjects().field_trials_init_string = nullptr;
 }
 
-static void JNI_PeerConnectionFactory_InvokeThreadsCallbacks(
-    JNIEnv*,
-    jlong j_p) {
-  OwnedFactoryAndThreads* factory =
-      reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
-  factory->InvokeJavaCallbacksOnFactoryThreads();
-}
-
 static jlong JNI_PeerConnectionFactory_CreateLocalMediaStream(
     JNIEnv* jni,
     jlong native_factory,
     const JavaParamRef<jstring>& label) {
-  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
-      factoryFromJava(native_factory));
   rtc::scoped_refptr<MediaStreamInterface> stream(
-      factory->CreateLocalMediaStream(JavaToStdString(jni, label)));
+      PeerConnectionFactoryFromJava(native_factory)
+          ->CreateLocalMediaStream(JavaToStdString(jni, label)));
   return jlongFromPointer(stream.release());
 }
 
@@ -341,12 +371,11 @@ static jlong JNI_PeerConnectionFactory_CreateAudioSource(
     const JavaParamRef<jobject>& j_constraints) {
   std::unique_ptr<MediaConstraintsInterface> constraints =
       JavaToNativeMediaConstraints(jni, j_constraints);
-  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
-      factoryFromJava(native_factory));
   cricket::AudioOptions options;
   CopyConstraintsIntoAudioOptions(constraints.get(), &options);
   rtc::scoped_refptr<AudioSourceInterface> source(
-      factory->CreateAudioSource(options));
+      PeerConnectionFactoryFromJava(native_factory)
+          ->CreateAudioSource(options));
   return jlongFromPointer(source.release());
 }
 
@@ -355,11 +384,11 @@ jlong JNI_PeerConnectionFactory_CreateAudioTrack(
     jlong native_factory,
     const JavaParamRef<jstring>& id,
     jlong native_source) {
-  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
+  rtc::scoped_refptr<AudioTrackInterface> track(
-      factoryFromJava(native_factory));
+      PeerConnectionFactoryFromJava(native_factory)
-  rtc::scoped_refptr<AudioTrackInterface> track(factory->CreateAudioTrack(
+          ->CreateAudioTrack(
-      JavaToStdString(jni, id),
+              JavaToStdString(jni, id),
-      reinterpret_cast<AudioSourceInterface*>(native_source)));
+              reinterpret_cast<AudioSourceInterface*>(native_source)));
   return jlongFromPointer(track.release());
 }
 
@@ -368,16 +397,13 @@ static jboolean JNI_PeerConnectionFactory_StartAecDump(
     jlong native_factory,
     jint file,
     jint filesize_limit_bytes) {
-  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
+  return PeerConnectionFactoryFromJava(native_factory)
-      factoryFromJava(native_factory));
+      ->StartAecDump(file, filesize_limit_bytes);
-  return factory->StartAecDump(file, filesize_limit_bytes);
 }
 
 static void JNI_PeerConnectionFactory_StopAecDump(JNIEnv* jni,
                                                   jlong native_factory) {
-  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
+  PeerConnectionFactoryFromJava(native_factory)->StopAecDump();
-      factoryFromJava(native_factory));
-  factory->StopAecDump();
 }
 
 static jlong JNI_PeerConnectionFactory_CreatePeerConnection(
@@ -387,9 +413,6 @@ static jlong JNI_PeerConnectionFactory_CreatePeerConnection(
     const JavaParamRef<jobject>& j_constraints,
     jlong observer_p,
     const JavaParamRef<jobject>& j_sslCertificateVerifier) {
-  rtc::scoped_refptr<PeerConnectionFactoryInterface> f(
-      reinterpret_cast<PeerConnectionFactoryInterface*>(
-          factoryFromJava(factory)));
   std::unique_ptr<PeerConnectionObserver> observer(
       reinterpret_cast<PeerConnectionObserver*>(observer_p));
 
@@ -426,11 +449,11 @@ static jlong JNI_PeerConnectionFactory_CreatePeerConnection(
             jni, j_sslCertificateVerifier);
   }
 
-  rtc::scoped_refptr<PeerConnectionInterface> pc(f->CreatePeerConnection(
+  rtc::scoped_refptr<PeerConnectionInterface> pc =
-      rtc_config, std::move(peer_connection_dependencies)));
+      PeerConnectionFactoryFromJava(factory)->CreatePeerConnection(
-  if (pc == nullptr) {
+          rtc_config, std::move(peer_connection_dependencies));
+  if (!pc)
     return 0;
-  }
 
   return jlongFromPointer(
       new OwnedPeerConnection(pc, std::move(observer), std::move(constraints)));
@@ -453,18 +476,18 @@ static jlong JNI_PeerConnectionFactory_CreateVideoTrack(
     jlong native_factory,
     const JavaParamRef<jstring>& id,
     jlong native_source) {
-  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
+  rtc::scoped_refptr<VideoTrackInterface> track =
-      factoryFromJava(native_factory));
+      PeerConnectionFactoryFromJava(native_factory)
-  rtc::scoped_refptr<VideoTrackInterface> track(factory->CreateVideoTrack(
+          ->CreateVideoTrack(
-      JavaToStdString(jni, id),
+              JavaToStdString(jni, id),
-      reinterpret_cast<VideoTrackSourceInterface*>(native_source)));
+              reinterpret_cast<VideoTrackSourceInterface*>(native_source));
   return jlongFromPointer(track.release());
 }
 
 static jlong JNI_PeerConnectionFactory_GetNativePeerConnectionFactory(
     JNIEnv* jni,
     jlong native_factory) {
-  return jlongFromPointer(factoryFromJava(native_factory));
+  return jlongFromPointer(PeerConnectionFactoryFromJava(native_factory));
 }
 
 static void JNI_PeerConnectionFactory_InjectLoggable(

sdk/android/src/jni/pc/peer_connection_factory.h

@@ -18,10 +18,6 @@
 namespace webrtc {
 namespace jni {
 
-void PeerConnectionFactoryNetworkThreadReady();
-void PeerConnectionFactoryWorkerThreadReady();
-void PeerConnectionFactorySignalingThreadReady();
-
 // Creates java PeerConnectionFactory with specified |pcf|.
 jobject NativeToJavaPeerConnectionFactory(
     JNIEnv* jni,