Move /webrtc/api/android files to /webrtc/sdk/android

webrtc/api/android/jni/jni_helpers.cc

Index: webrtc/api/android/jni/jni_helpers.cc
diff --git a/webrtc/api/android/jni/jni_helpers.cc b/webrtc/api/android/jni/jni_helpers.cc
deleted file mode 100644
index 3bc0ff995cad2f4f67196a63129a8a21e3f07d18..0000000000000000000000000000000000000000
--- a/webrtc/api/android/jni/jni_helpers.cc
+++ /dev/null
@@ -1,350 +0,0 @@
-/*
- *  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.
- */
-#include "webrtc/api/android/jni/jni_helpers.h"
-
-#include "webrtc/api/android/jni/classreferenceholder.h"
-
-#include <asm/unistd.h>
-#include <sys/prctl.h>
-#include <sys/syscall.h>
-#include <unistd.h>
-
-namespace webrtc_jni {
-
-static JavaVM* g_jvm = nullptr;
-
-static pthread_once_t g_jni_ptr_once = PTHREAD_ONCE_INIT;
-
-// Key for per-thread JNIEnv* data.  Non-NULL in threads attached to |g_jvm| by
-// AttachCurrentThreadIfNeeded(), NULL in unattached threads and threads that
-// were attached by the JVM because of a Java->native call.
-static pthread_key_t g_jni_ptr;
-
-JavaVM *GetJVM() {
-  RTC_CHECK(g_jvm) << "JNI_OnLoad failed to run?";
-  return g_jvm;
-}
-
-// Return a |JNIEnv*| usable on this thread or NULL if this thread is detached.
-JNIEnv* GetEnv() {
-  void* env = nullptr;
-  jint status = g_jvm->GetEnv(&env, JNI_VERSION_1_6);
-  RTC_CHECK(((env != nullptr) && (status == JNI_OK)) ||
-            ((env == nullptr) && (status == JNI_EDETACHED)))
-      << "Unexpected GetEnv return: " << status << ":" << env;
-  return reinterpret_cast<JNIEnv*>(env);
-}
-
-static void ThreadDestructor(void* prev_jni_ptr) {
-  // This function only runs on threads where |g_jni_ptr| is non-NULL, meaning
-  // we were responsible for originally attaching the thread, so are responsible
-  // for detaching it now.  However, because some JVM implementations (notably
-  // Oracle's http://goo.gl/eHApYT) also use the pthread_key_create mechanism,
-  // the JVMs accounting info for this thread may already be wiped out by the
-  // time this is called. Thus it may appear we are already detached even though
-  // it was our responsibility to detach!  Oh well.
-  if (!GetEnv())
-    return;
-
-  RTC_CHECK(GetEnv() == prev_jni_ptr)
-      << "Detaching from another thread: " << prev_jni_ptr << ":" << GetEnv();
-  jint status = g_jvm->DetachCurrentThread();
-  RTC_CHECK(status == JNI_OK) << "Failed to detach thread: " << status;
-  RTC_CHECK(!GetEnv()) << "Detaching was a successful no-op???";
-}
-
-static void CreateJNIPtrKey() {
-  RTC_CHECK(!pthread_key_create(&g_jni_ptr, &ThreadDestructor))
-      << "pthread_key_create";
-}
-
-jint InitGlobalJniVariables(JavaVM *jvm) {
-  RTC_CHECK(!g_jvm) << "InitGlobalJniVariables!";
-  g_jvm = jvm;
-  RTC_CHECK(g_jvm) << "InitGlobalJniVariables handed NULL?";
-
-  RTC_CHECK(!pthread_once(&g_jni_ptr_once, &CreateJNIPtrKey)) << "pthread_once";
-
-  JNIEnv* jni = nullptr;
-  if (jvm->GetEnv(reinterpret_cast<void**>(&jni), JNI_VERSION_1_6) != JNI_OK)
-    return -1;
-
-  return JNI_VERSION_1_6;
-}
-
-// Return thread ID as a string.
-static std::string GetThreadId() {
-  char buf[21];  // Big enough to hold a kuint64max plus terminating NULL.
-  RTC_CHECK_LT(snprintf(buf, sizeof(buf), "%ld",
-                        static_cast<long>(syscall(__NR_gettid))),
-               sizeof(buf))
-      << "Thread id is bigger than uint64??";
-  return std::string(buf);
-}
-
-// Return the current thread's name.
-static std::string GetThreadName() {
-  char name[17] = {0};
-  if (prctl(PR_GET_NAME, name) != 0)
-    return std::string("<noname>");
-  return std::string(name);
-}
-
-// Return a |JNIEnv*| usable on this thread.  Attaches to |g_jvm| if necessary.
-JNIEnv* AttachCurrentThreadIfNeeded() {
-  JNIEnv* jni = GetEnv();
-  if (jni)
-    return jni;
-  RTC_CHECK(!pthread_getspecific(g_jni_ptr))
-      << "TLS has a JNIEnv* but not attached?";
-
-  std::string name(GetThreadName() + " - " + GetThreadId());
-  JavaVMAttachArgs args;
-  args.version = JNI_VERSION_1_6;
-  args.name = &name[0];
-  args.group = nullptr;
-  // Deal with difference in signatures between Oracle's jni.h and Android's.
-#ifdef _JAVASOFT_JNI_H_  // Oracle's jni.h violates the JNI spec!
-  void* env = nullptr;
-#else
-  JNIEnv* env = nullptr;
-#endif
-  RTC_CHECK(!g_jvm->AttachCurrentThread(&env, &args))
-      << "Failed to attach thread";
-  RTC_CHECK(env) << "AttachCurrentThread handed back NULL!";
-  jni = reinterpret_cast<JNIEnv*>(env);
-  RTC_CHECK(!pthread_setspecific(g_jni_ptr, jni)) << "pthread_setspecific";
-  return jni;
-}
-
-// Return a |jlong| that will correctly convert back to |ptr|.  This is needed
-// because the alternative (of silently passing a 32-bit pointer to a vararg
-// function expecting a 64-bit param) picks up garbage in the high 32 bits.
-jlong jlongFromPointer(void* ptr) {
-  static_assert(sizeof(intptr_t) <= sizeof(jlong),
-                "Time to rethink the use of jlongs");
-  // Going through intptr_t to be obvious about the definedness of the
-  // conversion from pointer to integral type.  intptr_t to jlong is a standard
-  // widening by the static_assert above.
-  jlong ret = reinterpret_cast<intptr_t>(ptr);
-  RTC_DCHECK(reinterpret_cast<void*>(ret) == ptr);
-  return ret;
-}
-
-// JNIEnv-helper methods that RTC_CHECK success: no Java exception thrown and
-// found object/class/method/field is non-null.
-jmethodID GetMethodID(
-    JNIEnv* jni, jclass c, const std::string& name, const char* signature) {
-  jmethodID m = jni->GetMethodID(c, name.c_str(), signature);
-  CHECK_EXCEPTION(jni) << "error during GetMethodID: " << name << ", "
-                       << signature;
-  RTC_CHECK(m) << name << ", " << signature;
-  return m;
-}
-
-jmethodID GetStaticMethodID(
-    JNIEnv* jni, jclass c, const char* name, const char* signature) {
-  jmethodID m = jni->GetStaticMethodID(c, name, signature);
-  CHECK_EXCEPTION(jni) << "error during GetStaticMethodID: " << name << ", "
-                       << signature;
-  RTC_CHECK(m) << name << ", " << signature;
-  return m;
-}
-
-jfieldID GetFieldID(
-    JNIEnv* jni, jclass c, const char* name, const char* signature) {
-  jfieldID f = jni->GetFieldID(c, name, signature);
-  CHECK_EXCEPTION(jni) << "error during GetFieldID";
-  RTC_CHECK(f) << name << ", " << signature;
-  return f;
-}
-
-jclass GetObjectClass(JNIEnv* jni, jobject object) {
-  jclass c = jni->GetObjectClass(object);
-  CHECK_EXCEPTION(jni) << "error during GetObjectClass";
-  RTC_CHECK(c) << "GetObjectClass returned NULL";
-  return c;
-}
-
-jobject GetObjectField(JNIEnv* jni, jobject object, jfieldID id) {
-  jobject o = jni->GetObjectField(object, id);
-  CHECK_EXCEPTION(jni) << "error during GetObjectField";
-  RTC_CHECK(!IsNull(jni, o)) << "GetObjectField returned NULL";
-  return o;
-}
-
-jobject GetNullableObjectField(JNIEnv* jni, jobject object, jfieldID id) {
-  jobject o = jni->GetObjectField(object, id);
-  CHECK_EXCEPTION(jni) << "error during GetObjectField";
-  return o;
-}
-
-jstring GetStringField(JNIEnv* jni, jobject object, jfieldID id) {
-  return static_cast<jstring>(GetObjectField(jni, object, id));
-}
-
-jlong GetLongField(JNIEnv* jni, jobject object, jfieldID id) {
-  jlong l = jni->GetLongField(object, id);
-  CHECK_EXCEPTION(jni) << "error during GetLongField";
-  return l;
-}
-
-jint GetIntField(JNIEnv* jni, jobject object, jfieldID id) {
-  jint i = jni->GetIntField(object, id);
-  CHECK_EXCEPTION(jni) << "error during GetIntField";
-  return i;
-}
-
-bool GetBooleanField(JNIEnv* jni, jobject object, jfieldID id) {
-  jboolean b = jni->GetBooleanField(object, id);
-  CHECK_EXCEPTION(jni) << "error during GetBooleanField";
-  return b;
-}
-
-bool IsNull(JNIEnv* jni, jobject obj) {
-  return jni->IsSameObject(obj, nullptr);
-}
-
-// Given a UTF-8 encoded |native| string return a new (UTF-16) jstring.
-jstring JavaStringFromStdString(JNIEnv* jni, const std::string& native) {
-  jstring jstr = jni->NewStringUTF(native.c_str());
-  CHECK_EXCEPTION(jni) << "error during NewStringUTF";
-  return jstr;
-}
-
-// Given a (UTF-16) jstring return a new UTF-8 native string.
-std::string JavaToStdString(JNIEnv* jni, const jstring& j_string) {
-  const char* chars = jni->GetStringUTFChars(j_string, nullptr);
-  CHECK_EXCEPTION(jni) << "Error during GetStringUTFChars";
-  std::string str(chars, jni->GetStringUTFLength(j_string));
-  CHECK_EXCEPTION(jni) << "Error during GetStringUTFLength";
-  jni->ReleaseStringUTFChars(j_string, chars);
-  CHECK_EXCEPTION(jni) << "Error during ReleaseStringUTFChars";
-  return str;
-}
-
-// Return the (singleton) Java Enum object corresponding to |index|;
-jobject JavaEnumFromIndex(JNIEnv* jni, jclass state_class,
-                          const std::string& state_class_name, int index) {
-  jmethodID state_values_id = GetStaticMethodID(
-      jni, state_class, "values", ("()[L" + state_class_name  + ";").c_str());
-  jobjectArray state_values = static_cast<jobjectArray>(
-      jni->CallStaticObjectMethod(state_class, state_values_id));
-  CHECK_EXCEPTION(jni) << "error during CallStaticObjectMethod";
-  jobject ret = jni->GetObjectArrayElement(state_values, index);
-  CHECK_EXCEPTION(jni) << "error during GetObjectArrayElement";
-  return ret;
-}
-
-std::string GetJavaEnumName(JNIEnv* jni,
-                            const std::string& className,
-                            jobject j_enum) {
-  jclass enumClass = FindClass(jni, className.c_str());
-  jmethodID nameMethod =
-      GetMethodID(jni, enumClass, "name", "()Ljava/lang/String;");
-  jstring name =
-      reinterpret_cast<jstring>(jni->CallObjectMethod(j_enum, nameMethod));
-  CHECK_EXCEPTION(jni) << "error during CallObjectMethod for " << className
-                       << ".name";
-  return JavaToStdString(jni, name);
-}
-
-jobject NewGlobalRef(JNIEnv* jni, jobject o) {
-  jobject ret = jni->NewGlobalRef(o);
-  CHECK_EXCEPTION(jni) << "error during NewGlobalRef";
-  RTC_CHECK(ret);
-  return ret;
-}
-
-void DeleteGlobalRef(JNIEnv* jni, jobject o) {
-  jni->DeleteGlobalRef(o);
-  CHECK_EXCEPTION(jni) << "error during DeleteGlobalRef";
-}
-
-// Scope Java local references to the lifetime of this object.  Use in all C++
-// callbacks (i.e. entry points that don't originate in a Java callstack
-// through a "native" method call).
-ScopedLocalRefFrame::ScopedLocalRefFrame(JNIEnv* jni) : jni_(jni) {
-  RTC_CHECK(!jni_->PushLocalFrame(0)) << "Failed to PushLocalFrame";
-}
-ScopedLocalRefFrame::~ScopedLocalRefFrame() {
-  jni_->PopLocalFrame(nullptr);
-}
-
-// Creates an iterator representing the end of any collection.
-Iterable::Iterator::Iterator() : iterator_(nullptr) {}
-
-// Creates an iterator pointing to the beginning of the specified collection.
-Iterable::Iterator::Iterator(JNIEnv* jni, jobject iterable) : jni_(jni) {
-  jclass j_class = GetObjectClass(jni, iterable);
-  jmethodID iterator_id =
-      GetMethodID(jni, j_class, "iterator", "()Ljava/util/Iterator;");
-  iterator_ = jni->CallObjectMethod(iterable, iterator_id);
-  CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
-  RTC_CHECK(iterator_ != nullptr);
-
-  jclass iterator_class = GetObjectClass(jni, iterator_);
-  has_next_id_ = GetMethodID(jni, iterator_class, "hasNext", "()Z");
-  next_id_ = GetMethodID(jni, iterator_class, "next", "()Ljava/lang/Object;");
-
-  // Start at the first element in the collection.
-  ++(*this);
-}
-
-// Move constructor - necessary to be able to return iterator types from
-// functions.
-Iterable::Iterator::Iterator(Iterator&& other)
-    : jni_(std::move(other.jni_)),
-      iterator_(std::move(other.iterator_)),
-      value_(std::move(other.value_)),
-      has_next_id_(std::move(other.has_next_id_)),
-      next_id_(std::move(other.next_id_)),
-      thread_checker_(std::move(other.thread_checker_)){};
-
-// Advances the iterator one step.
-Iterable::Iterator& Iterable::Iterator::operator++() {
-  RTC_CHECK(thread_checker_.CalledOnValidThread());
-  if (AtEnd()) {
-    // Can't move past the end.
-    return *this;
-  }
-  bool has_next = jni_->CallBooleanMethod(iterator_, has_next_id_);
-  CHECK_EXCEPTION(jni_) << "error during CallBooleanMethod";
-  if (!has_next) {
-    iterator_ = nullptr;
-    value_ = nullptr;
-    return *this;
-  }
-
-  value_ = jni_->CallObjectMethod(iterator_, next_id_);
-  CHECK_EXCEPTION(jni_) << "error during CallObjectMethod";
-  return *this;
-}
-
-// Provides a way to compare the iterator with itself and with the end iterator.
-// Note: all other comparison results are undefined, just like for C++ input
-// iterators.
-bool Iterable::Iterator::operator==(const Iterable::Iterator& other) {
-  // Two different active iterators should never be compared.
-  RTC_DCHECK(this == &other || AtEnd() || other.AtEnd());
-  return AtEnd() == other.AtEnd();
-}
-
-jobject Iterable::Iterator::operator*() {
-  RTC_CHECK(!AtEnd());
-  return value_;
-}
-
-bool Iterable::Iterator::AtEnd() const {
-  RTC_CHECK(thread_checker_.CalledOnValidThread());
-  return jni_ == nullptr || IsNull(jni_, iterator_);
-}
-
-}  // namespace webrtc_jni