Relanding: Break peerconnection_jni.cc into multiple files, in "pc" directory.

webrtc/sdk/android/src/jni/jni_helpers.h

 /*
  *  Copyright 2015 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 16 matching lines @@
 // to the error stream.
 #define CHECK_EXCEPTION(jni)        \
   RTC_CHECK(!jni->ExceptionCheck()) \
       << (jni->ExceptionDescribe(), jni->ExceptionClear(), "")
 
 // Helper that calls ptr->Release() and aborts the process with a useful
 // message if that didn't actually delete *ptr because of extra refcounts.
 #define CHECK_RELEASE(ptr) \
   RTC_CHECK_EQ(0, (ptr)->Release()) << "Unexpected refcount."
 
+// Convenience macro defining JNI-accessible methods in the org.webrtc package.
+// Eliminates unnecessary boilerplate and line-wraps, reducing visual clutter.
+#define JOW(rettype, name) \

[magjed_webrtc, 2017/08/01 12:52:17]

This is unrelated to your CL, but I have been planning to deprecate this macro
as I think it's counterproductive. It's more transparent and easier on my eyes
to see a normal function declaration than this macro. Also, clang format works
much better without this macro which also improves readability.

If you agree, please add a comment that this macro is deprecated and that the
preferred way is to write out the full function declaration.

[Taylor Brandstetter, 2017/08/01 20:53:54]

I'm not sure I agree; it may be more transparent, but 'extern "C" JNIEXPORT void
JNICALL Java_org_webrtc_nativeFoo' isn't really easy on the eyes to me. And
having to type it out could result in mistakes that were otherwise not possible,
or code reviewers missing a detail in the noise. Is there another reason I'm
missing? Because I don't think transparency is reason enough. It's easy to look
at the definition here if one actually cares (which shouldn't be too frequent).

For the clang format point, it would be easy to change the macro to:

#define JOW(rettype, name, ...) \
   extern "C" JNIEXPORT rettype JNICALL Java_org_webrtc_##name(__VA_ARGS__)

In other words, putting the arguments in the same set of parens. Which
clang-format is much kinder to.

[magjed_webrtc, 2017/08/02 14:15:46]

So we have three different options. A concrete example looks like:

extern "C" JNIEXPORT void JNICALL
Java_org_webrtc_VideoTrack_nativeAddRenderer(JNIEnv* jni,
                                             jclass,
                                             jlong j_video_track_pointer,
                                             jlong j_renderer_pointer) {
  ...
}

JOW(void, VideoTrack_nativeAddRenderer)
(JNIEnv* jni, jclass, jlong j_video_track_pointer, jlong j_renderer_pointer) {
  ...
}

JOW(void,
    VideoTrack_nativeAddRenderer,
    JNIEnv* jni,
    jclass,
    jlong j_video_track_pointer,
    jlong j_renderer_pointer) {
  ...
}

I'm leaning towards the #define JOW(rettype, name, ...) option which looks much
nicer than the current #define JOW(rettype, name) option (thanks for suggesting
it!). If we change it, we should probably also change the name from JOW to
something more descriptive like JNI_FUNCTION_DECLARATION.

It's not a big deal, so it's perfectly fine if you just want to leave the macro
as is for now.

[Taylor Brandstetter, 2017/08/02 21:13:49]

Since this CL already probably makes more changes than it should, I'll save this
for a second CL and add a TODO for now.

+  extern "C" JNIEXPORT rettype JNICALL Java_org_webrtc_##name
+
 namespace webrtc_jni {
 
 jint InitGlobalJniVariables(JavaVM *jvm);
 
 // Return a |JNIEnv*| usable on this thread or NULL if this thread is detached.
 JNIEnv* GetEnv();
 
 JavaVM *GetJVM();
 
 // Return a |JNIEnv*| usable on this thread.  Attaches to |g_jvm| if necessary.
@@ skipping 43 matching lines @@
 // Given a UTF-8 encoded |native| string return a new (UTF-16) jstring.
 jstring JavaStringFromStdString(JNIEnv* jni, const std::string& native);
 
 // Given a (UTF-16) jstring return a new UTF-8 native string.
 std::string JavaToStdString(JNIEnv* jni, const jstring& j_string);
 
 // Return the (singleton) Java Enum object corresponding to |index|;
 jobject JavaEnumFromIndex(JNIEnv* jni, jclass state_class,
                           const std::string& state_class_name, int index);
 
+// Return the (singleton) Java Enum object corresponding to |index|;
+// |state_class_fragment| is something like "MediaSource$State".
+jobject JavaEnumFromIndexAndClassName(JNIEnv* jni,
+                                      const std::string& state_class_fragment,
+                                      int index);
+
 // Returns the name of a Java enum.
 std::string GetJavaEnumName(JNIEnv* jni,
                             const std::string& className,
                             jobject j_enum);
 
 jobject NewGlobalRef(JNIEnv* jni, jobject o);
 
 void DeleteGlobalRef(JNIEnv* jni, jobject o);
 
 // Scope Java local references to the lifetime of this object.  Use in all C++
@@ skipping 79 matching lines @@
  private:
   JNIEnv* jni_;
   jobject iterable_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Iterable);
 };
 
 }  // namespace webrtc_jni
 
 #endif  // WEBRTC_SDK_ANDROID_SRC_JNI_JNI_HELPERS_H_