Remove Java PC support.

talk/app/webrtc/java/jni/peerconnection_jni.cc

 /*
  * libjingle
  * Copyright 2013 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 41 matching lines @@
 // return to the Java frame that called code in this file, at which point it's
 // impossible to tell which JNI call broke).
 
 #include <jni.h>
 #undef JNIEXPORT
 #define JNIEXPORT __attribute__((visibility("default")))
 
 #include <limits>
 #include <utility>
 
+#include "talk/app/webrtc/androidvideocapturer.h"
+#include "talk/app/webrtc/java/jni/androidmediadecoder_jni.h"
+#include "talk/app/webrtc/java/jni/androidmediaencoder_jni.h"
+#include "talk/app/webrtc/java/jni/androidvideocapturer_jni.h"
+#include "talk/app/webrtc/java/jni/androidnetworkmonitor_jni.h"
 #include "talk/app/webrtc/java/jni/classreferenceholder.h"
 #include "talk/app/webrtc/java/jni/jni_helpers.h"
 #include "talk/app/webrtc/java/jni/native_handle_impl.h"
 #include "talk/app/webrtc/dtlsidentitystore.h"
 #include "talk/app/webrtc/mediaconstraintsinterface.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
 #include "talk/app/webrtc/rtpreceiverinterface.h"
 #include "talk/app/webrtc/rtpsenderinterface.h"
 #include "talk/app/webrtc/videosourceinterface.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/videorenderer.h"
 #include "talk/media/devices/videorendererfactory.h"
 #include "talk/media/webrtc/webrtcvideodecoderfactory.h"
 #include "talk/media/webrtc/webrtcvideoencoderfactory.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/event_tracer.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/logsinks.h"
 #include "webrtc/base/messagequeue.h"
 #include "webrtc/base/networkmonitor.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/system_wrappers/include/field_trial_default.h"
+#include "webrtc/system_wrappers/include/logcat_trace_context.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/voice_engine/include/voe_base.h"
 
-#if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
-#include "talk/app/webrtc/androidvideocapturer.h"
-#include "talk/app/webrtc/java/jni/androidmediadecoder_jni.h"
-#include "talk/app/webrtc/java/jni/androidmediaencoder_jni.h"
-#include "talk/app/webrtc/java/jni/androidvideocapturer_jni.h"
-#include "talk/app/webrtc/java/jni/androidnetworkmonitor_jni.h"
-#include "webrtc/modules/video_render/video_render_internal.h"
-#include "webrtc/system_wrappers/include/logcat_trace_context.h"
-using webrtc::LogcatTraceContext;
-#endif
-
 using cricket::WebRtcVideoDecoderFactory;
 using cricket::WebRtcVideoEncoderFactory;
 using rtc::Bind;
 using rtc::Thread;
 using rtc::ThreadManager;
 using rtc::scoped_ptr;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrackInterface;
 using webrtc::AudioTrackVector;
 using webrtc::CreateSessionDescriptionObserver;
 using webrtc::DataBuffer;
 using webrtc::DataChannelInit;
 using webrtc::DataChannelInterface;
 using webrtc::DataChannelObserver;
 using webrtc::IceCandidateInterface;
+using webrtc::LogcatTraceContext;
 using webrtc::MediaConstraintsInterface;
 using webrtc::MediaSourceInterface;
 using webrtc::MediaStreamInterface;
 using webrtc::MediaStreamTrackInterface;
 using webrtc::PeerConnectionFactoryInterface;
 using webrtc::PeerConnectionInterface;
 using webrtc::PeerConnectionObserver;
 using webrtc::RtpReceiverInterface;
 using webrtc::RtpSenderInterface;
 using webrtc::SessionDescriptionInterface;
 using webrtc::SetSessionDescriptionObserver;
 using webrtc::StatsObserver;
 using webrtc::StatsReport;
 using webrtc::StatsReports;
 using webrtc::VideoRendererInterface;
 using webrtc::VideoSourceInterface;
 using webrtc::VideoTrackInterface;
 using webrtc::VideoTrackVector;
 using webrtc::kVideoCodecVP8;
 
 namespace webrtc_jni {
 
 // Field trials initialization string
 static char *field_trials_init_string = NULL;
 
-#if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
 // Set in PeerConnectionFactory_initializeAndroidGlobals().
 static bool factory_static_initialized = false;
 static bool video_hw_acceleration_enabled = true;
-#endif
 
 // Return the (singleton) Java Enum object corresponding to |index|;
 // |state_class_fragment| is something like "MediaSource$State".
 static jobject JavaEnumFromIndex(
     JNIEnv* jni, const std::string& state_class_fragment, int index) {
   const std::string state_class = "org/webrtc/" + state_class_fragment;
   return JavaEnumFromIndex(jni, FindClass(jni, state_class.c_str()),
                            state_class, index);
 }
 
@@ skipping 727 matching lines @@
 JOW(void, DataChannel_dispose)(JNIEnv* jni, jobject j_dc) {
   CHECK_RELEASE(ExtractNativeDC(jni, j_dc));
 }
 
 JOW(void, Logging_nativeEnableTracing)(
     JNIEnv* jni, jclass, jstring j_path, jint nativeLevels,
     jint nativeSeverity) {
   std::string path = JavaToStdString(jni, j_path);
   if (nativeLevels != webrtc::kTraceNone) {
     webrtc::Trace::set_level_filter(nativeLevels);
-#if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
     if (path != "logcat:") {
-#endif
       RTC_CHECK_EQ(0, webrtc::Trace::SetTraceFile(path.c_str(), false))
           << "SetTraceFile failed";
-#if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
     } else {
       // Intentionally leak this to avoid needing to reason about its lifecycle.
       // It keeps no state and functions only as a dispatch point.
       static LogcatTraceContext* g_trace_callback = new LogcatTraceContext();
     }
-#endif
   }
   if (nativeSeverity >= rtc::LS_SENSITIVE && nativeSeverity <= rtc::LS_ERROR) {
     rtc::LogMessage::LogToDebug(
         static_cast<rtc::LoggingSeverity>(nativeSeverity));
   }
 }
 
 JOW(void, Logging_nativeEnableLogThreads)(JNIEnv* jni, jclass) {
   rtc::LogMessage::LogThreads(true);
 }
@@ skipping 19 matching lines @@
 }
 
 JOW(void, MediaSource_free)(JNIEnv*, jclass, jlong j_p) {
   CHECK_RELEASE(reinterpret_cast<MediaSourceInterface*>(j_p));
 }
 
 JOW(void, VideoCapturer_free)(JNIEnv*, jclass, jlong j_p) {
   delete reinterpret_cast<cricket::VideoCapturer*>(j_p);
 }
 
 JOW(void, VideoRenderer_freeGuiVideoRenderer)(JNIEnv*, jclass, jlong j_p) {

[AlexG, 2016/02/01 21:05:33]

Not needed?

[magjed_webrtc, 2016/02/02 09:00:01]

Yes, I think VideoRenderer can be cleaned up as well.

[perkj_webrtc, 2016/02/03 17:00:03]

Used by VideoRenderer.createGui which is used by PeerConnectionTest. I don't
want to refactor in this cl.

[AlexG, 2016/02/04 00:01:22]

Add TODO item since I think nativeCreateGuiVideoRenderer can not be used on
Android?

[perkj_webrtc, 2016/02/05 13:43:44]

you are actually right. The test did call this method but there was a condition
that made sure it was not called. So I cleaned this too.

   delete reinterpret_cast<VideoRendererWrapper*>(j_p);
 }
 
 JOW(void, VideoRenderer_freeWrappedVideoRenderer)(JNIEnv*, jclass, jlong j_p) {
   delete reinterpret_cast<JavaVideoRendererWrapper*>(j_p);
 }
 
 JOW(void, VideoRenderer_releaseNativeFrame)(
     JNIEnv* jni, jclass, jlong j_frame_ptr) {
   delete reinterpret_cast<const cricket::VideoFrame*>(j_frame_ptr);
@@ skipping 34 matching lines @@
 
 JOW(void, MediaStream_free)(JNIEnv*, jclass, jlong j_p) {
   CHECK_RELEASE(reinterpret_cast<MediaStreamInterface*>(j_p));
 }
 
 JOW(jlong, PeerConnectionFactory_nativeCreateObserver)(
     JNIEnv * jni, jclass, jobject j_observer) {
   return (jlong)new PCOJava(jni, j_observer);
 }
 
-#if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
 JOW(jboolean, PeerConnectionFactory_initializeAndroidGlobals)(
     JNIEnv* jni, jclass, jobject context,
     jboolean initialize_audio, jboolean initialize_video,
     jboolean video_hw_acceleration) {
   bool failure = false;
   video_hw_acceleration_enabled = video_hw_acceleration;
   AndroidNetworkMonitor::SetAndroidContext(jni, context);
   if (!factory_static_initialized) {
     if (initialize_video) {
-      failure |= webrtc::SetRenderAndroidVM(GetJVM());
       failure |= AndroidVideoCapturerJni::SetAndroidObjects(jni, context);
     }
     if (initialize_audio)
       failure |= webrtc::VoiceEngine::SetAndroidObjects(GetJVM(), context);
     factory_static_initialized = true;
   }
   return !failure;
 }
-#endif  // defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
 
 JOW(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);
@@ skipping 150 matching lines @@
       << "Failed to start threads";
   WebRtcVideoEncoderFactory* encoder_factory = nullptr;
   WebRtcVideoDecoderFactory* decoder_factory = nullptr;
   rtc::NetworkMonitorFactory* network_monitor_factory = nullptr;
 
   PeerConnectionFactoryInterface::Options options;
   bool has_options = joptions != NULL;
   if (has_options) {
     options = ParseOptionsFromJava(jni, joptions);
   }
-#if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
+
   if (video_hw_acceleration_enabled) {
     encoder_factory = new MediaCodecVideoEncoderFactory();
     decoder_factory = new MediaCodecVideoDecoderFactory();
   }
   // 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)) {
     network_monitor_factory = new AndroidNetworkMonitorFactory();
     rtc::NetworkMonitorFactory::SetFactory(network_monitor_factory);
   }
-#endif
+
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       webrtc::CreatePeerConnectionFactory(worker_thread,
                                           signaling_thread,
                                           NULL,
                                           encoder_factory,
                                           decoder_factory));
   RTC_CHECK(factory) << "Failed to create the peer connection factory; "
                      << "WebRTC/libjingle init likely failed on this device";
   // TODO(honghaiz): Maybe put the options as the argument of
   // CreatePeerConnectionFactory.
@@ skipping 82 matching lines @@
       factoryFromJava(native_factory));
   rtc::scoped_refptr<AudioTrackInterface> track(factory->CreateAudioTrack(
       JavaToStdString(jni, id),
       reinterpret_cast<AudioSourceInterface*>(native_source)));
   return (jlong)track.release();
 }
 
 JOW(jboolean, PeerConnectionFactory_nativeStartAecDump)(
     JNIEnv* jni, jclass, jlong native_factory, jint file,
     jint filesize_limit_bytes) {
-#if defined(ANDROID)
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   return factory->StartAecDump(file, filesize_limit_bytes);
-#else
-  return false;
-#endif
 }
 
 JOW(void, PeerConnectionFactory_nativeStopAecDump)(
     JNIEnv* jni, jclass, jlong native_factory) {
-#if defined(ANDROID)
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   factory->StopAecDump();
-#endif
 }
 
 JOW(jboolean, PeerConnectionFactory_nativeStartRtcEventLog)(
     JNIEnv* jni, jclass, jlong native_factory, jint file) {
-#if defined(ANDROID)
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   return factory->StartRtcEventLog(file);
-#else
-  return false;
-#endif
 }
 
 JOW(void, PeerConnectionFactory_nativeStopRtcEventLog)(
     JNIEnv* jni, jclass, jlong native_factory) {
-#if defined(ANDROID)
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   factory->StopRtcEventLog();
-#endif
 }
 
 JOW(void, PeerConnectionFactory_nativeSetOptions)(
     JNIEnv* jni, jclass, jlong native_factory, jobject options) {
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   PeerConnectionFactoryInterface::Options options_to_set =
       ParseOptionsFromJava(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(void, PeerConnectionFactory_nativeSetVideoHwAccelerationOptions)(
     JNIEnv* jni, jclass, jlong native_factory, jobject local_egl_context,
     jobject remote_egl_context) {
-#if defined(ANDROID) && !defined(WEBRTC_CHROMIUM_BUILD)
   OwnedFactoryAndThreads* owned_factory =
       reinterpret_cast<OwnedFactoryAndThreads*>(native_factory);
 
   jclass j_eglbase14_context_class =
       FindClass(jni, "org/webrtc/EglBase14$Context");
 
   MediaCodecVideoEncoderFactory* encoder_factory =
       static_cast<MediaCodecVideoEncoderFactory*>
           (owned_factory->encoder_factory());
   if (encoder_factory &&
       jni->IsInstanceOf(local_egl_context, j_eglbase14_context_class)) {
     LOG(LS_INFO) << "Set EGL context for HW encoding.";
     encoder_factory->SetEGLContext(jni, local_egl_context);
   }
 
   MediaCodecVideoDecoderFactory* decoder_factory =
       static_cast<MediaCodecVideoDecoderFactory*>
           (owned_factory->decoder_factory());
   if (decoder_factory &&
       jni->IsInstanceOf(remote_egl_context, j_eglbase14_context_class)) {
     LOG(LS_INFO) << "Set EGL context for HW decoding.";
     decoder_factory->SetEGLContext(jni, remote_egl_context);
   }
-#endif
 }
 
 static PeerConnectionInterface::IceTransportsType
 JavaIceTransportsTypeToNativeType(JNIEnv* jni, jobject j_ice_transports_type) {
   std::string enum_name = GetJavaEnumName(
       jni, "org/webrtc/PeerConnection$IceTransportsType",
       j_ice_transports_type);
 
   if (enum_name == "ALL")
     return PeerConnectionInterface::kAll;
@@ skipping 489 matching lines @@
   ExtractNativePC(jni, j_pc)->Close();
   return;
 }
 
 JOW(jobject, MediaSource_nativeState)(JNIEnv* jni, jclass, jlong j_p) {
   rtc::scoped_refptr<MediaSourceInterface> p(
       reinterpret_cast<MediaSourceInterface*>(j_p));
   return JavaEnumFromIndex(jni, "MediaSource$State", p->state());
 }
 
-JOW(jobject, VideoCapturer_nativeCreateVideoCapturer)(
-    JNIEnv* jni, jclass, jstring j_device_name) {
-// Since we can't create platform specific java implementations in Java, we
-// defer the creation to C land.
-#if defined(ANDROID)
-  // TODO(nisse): This case is intended to be deleted.

[phoglund, 2016/02/02 08:04:43]

But this deletes the android implementation as well, is that intended?

[perkj_webrtc, 2016/02/03 17:00:03]

Yes. it it no longer used.

-  jclass j_video_capturer_class(
-      FindClass(jni, "org/webrtc/VideoCapturerAndroid"));
-  const int camera_id = jni->CallStaticIntMethod(
-      j_video_capturer_class,
-      GetStaticMethodID(jni, j_video_capturer_class, "lookupDeviceName",
-                        "(Ljava/lang/String;)I"),
-      j_device_name);
-  CHECK_EXCEPTION(jni) << "error during VideoCapturerAndroid.lookupDeviceName";
-  if (camera_id == -1)
-    return nullptr;
-  jobject j_video_capturer = jni->NewObject(
-      j_video_capturer_class,
-      GetMethodID(jni, j_video_capturer_class, "<init>", "(I)V"), camera_id);
-  CHECK_EXCEPTION(jni) << "error during creation of VideoCapturerAndroid";
-  jfieldID helper_fid = GetFieldID(jni, j_video_capturer_class, "surfaceHelper",
-                                   "Lorg/webrtc/SurfaceTextureHelper;");
-
-  rtc::scoped_refptr<webrtc::AndroidVideoCapturerDelegate> delegate =
-      new rtc::RefCountedObject<AndroidVideoCapturerJni>(
-          jni, j_video_capturer,
-          GetObjectField(jni, j_video_capturer, helper_fid));
-  rtc::scoped_ptr<cricket::VideoCapturer> capturer(
-      new webrtc::AndroidVideoCapturer(delegate));
-
-#else
-  std::string device_name = JavaToStdString(jni, j_device_name);
-  scoped_ptr<cricket::DeviceManagerInterface> device_manager(
-      cricket::DeviceManagerFactory::Create());
-  RTC_CHECK(device_manager->Init()) << "DeviceManager::Init() failed";
-  cricket::Device device;
-  if (!device_manager->GetVideoCaptureDevice(device_name, &device)) {
-    LOG(LS_ERROR) << "GetVideoCaptureDevice failed for " << device_name;
-    return 0;
-  }
-  scoped_ptr<cricket::VideoCapturer> capturer(
-      device_manager->CreateVideoCapturer(device));
-
-  jclass j_video_capturer_class(
-      FindClass(jni, "org/webrtc/VideoCapturer"));
-  const jmethodID j_videocapturer_ctor(GetMethodID(
-      jni, j_video_capturer_class, "<init>", "()V"));
-  jobject j_video_capturer =
-      jni->NewObject(j_video_capturer_class,
-                     j_videocapturer_ctor);
-  CHECK_EXCEPTION(jni) << "error during creation of VideoCapturer";
-
-#endif
-  const jmethodID j_videocapturer_set_native_capturer(GetMethodID(
-      jni, j_video_capturer_class, "setNativeCapturer", "(J)V"));
-  jni->CallVoidMethod(j_video_capturer,
-                      j_videocapturer_set_native_capturer,
-                      jlongFromPointer(capturer.release()));
-  CHECK_EXCEPTION(jni) << "error during setNativeCapturer";
-  return j_video_capturer;
-}
-
 JOW(jlong, VideoRenderer_nativeCreateGuiVideoRenderer)(

[AlexG, 2016/02/01 21:05:33]

Not needed as well? I may be wrong, but I think this API was used on Linux only

[perkj_webrtc, 2016/02/03 17:00:03]

dito- It is still used by PeerConnectionTest. 

     JNIEnv* jni, jclass, int x, int y) {
   scoped_ptr<VideoRendererWrapper> renderer(VideoRendererWrapper::Create(
       cricket::VideoRendererFactory::CreateGuiVideoRenderer(x, y)));
   return (jlong)renderer.release();
 }
 
 JOW(jlong, VideoRenderer_nativeWrapVideoRenderer)(
     JNIEnv* jni, jclass, jobject j_callbacks) {
   scoped_ptr<JavaVideoRendererWrapper> renderer(
       new JavaVideoRendererWrapper(jni, j_callbacks));
@@ skipping 179 matching lines @@
   return JavaStringFromStdString(
       jni,
       reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->id());
 }
 
 JOW(void, RtpReceiver_free)(JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer) {
   reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->Release();
 }
 
 }  // namespace webrtc_jni