1328 lines
51 KiB
C++
1328 lines
51 KiB
C++
// Copyright (c) 2013 The Chromium Embedded Framework Authors. All rights
|
|
// reserved. Use of this source code is governed by a BSD-style license that
|
|
// can be found in the LICENSE file.
|
|
|
|
#include "jni_util.h"
|
|
|
|
#include <jawt.h>
|
|
#include <algorithm>
|
|
|
|
#include "jni_scoped_helpers.h"
|
|
|
|
#include "include/cef_base.h"
|
|
|
|
namespace {
|
|
|
|
JavaVM* g_jvm = nullptr;
|
|
|
|
jobject g_javaClassLoader = nullptr;
|
|
|
|
} // namespace
|
|
|
|
void SetJVM(JavaVM* jvm) {
|
|
ASSERT(!g_jvm);
|
|
g_jvm = jvm;
|
|
}
|
|
|
|
JavaVM* GetJVM() {
|
|
return g_jvm;
|
|
}
|
|
|
|
void SetJavaClassLoader(JNIEnv* env, jobject javaClassLoader) {
|
|
ASSERT(!g_javaClassLoader);
|
|
g_javaClassLoader = env->NewGlobalRef(javaClassLoader);
|
|
}
|
|
|
|
jobject GetJavaClassLoader() {
|
|
return g_javaClassLoader;
|
|
}
|
|
|
|
jobject NewJNIObject(JNIEnv* env, jclass cls) {
|
|
jmethodID initID = env->GetMethodID(cls, "<init>", "()V");
|
|
if (initID == 0) {
|
|
env->ExceptionClear();
|
|
return nullptr;
|
|
}
|
|
|
|
jobject obj = env->NewObject(cls, initID);
|
|
if (obj == nullptr) {
|
|
env->ExceptionClear();
|
|
return nullptr;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
jobject NewJNIObject(JNIEnv* env, const char* class_name) {
|
|
ScopedJNIClass cls(env, class_name);
|
|
if (!cls)
|
|
return nullptr;
|
|
|
|
return NewJNIObject(env, cls);
|
|
}
|
|
|
|
jobject NewJNIObject(JNIEnv* env,
|
|
const char* class_name,
|
|
const char* sig,
|
|
...) {
|
|
ScopedJNIClass cls(env, class_name);
|
|
if (!cls)
|
|
return nullptr;
|
|
|
|
jmethodID initID = env->GetMethodID(cls, "<init>", sig);
|
|
if (initID == 0) {
|
|
env->ExceptionClear();
|
|
return nullptr;
|
|
}
|
|
|
|
va_list ap;
|
|
va_start(ap, sig);
|
|
|
|
jobject obj = env->NewObjectV(cls, initID, ap);
|
|
if (obj == nullptr) {
|
|
env->ExceptionClear();
|
|
return nullptr;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
bool GetJNIBoolRef(JNIEnv* env, jobject jboolRef) {
|
|
jboolean boolRefRes = JNI_FALSE;
|
|
JNI_CALL_METHOD(env, jboolRef, "get", "()Z", Boolean, boolRefRes);
|
|
return (boolRefRes != JNI_FALSE);
|
|
}
|
|
|
|
int GetJNIIntRef(JNIEnv* env, jobject jintRef) {
|
|
jint intRefRes = -1;
|
|
JNI_CALL_METHOD(env, jintRef, "get", "()I", Int, intRefRes);
|
|
return intRefRes;
|
|
}
|
|
|
|
int64_t GetJNILongRef(JNIEnv* env, jobject jlongRef) {
|
|
jlong longRefRes = -1;
|
|
JNI_CALL_METHOD(env, jlongRef, "get", "()J", Long, longRefRes);
|
|
return longRefRes;
|
|
}
|
|
|
|
CefString GetJNIStringRef(JNIEnv* env, jobject jstringRef) {
|
|
ScopedJNIStringResult str(env);
|
|
JNI_CALL_METHOD(env, jstringRef, "get", "()Ljava/lang/String;", Object, str);
|
|
return str.GetCefString();
|
|
}
|
|
|
|
void SetJNIBoolRef(JNIEnv* env, jobject jboolRef, bool boolValue) {
|
|
JNI_CALL_VOID_METHOD(env, jboolRef, "set", "(Z)V",
|
|
(boolValue ? JNI_TRUE : JNI_FALSE));
|
|
}
|
|
|
|
void SetJNIIntRef(JNIEnv* env, jobject jintRef, int intValue) {
|
|
JNI_CALL_VOID_METHOD(env, jintRef, "set", "(I)V", intValue);
|
|
}
|
|
|
|
void SetJNILongRef(JNIEnv* env, jobject jlongRef, int64_t longValue) {
|
|
JNI_CALL_VOID_METHOD(env, jlongRef, "set", "(J)V", longValue);
|
|
}
|
|
|
|
void SetJNIStringRef(JNIEnv* env,
|
|
jobject jstringRef,
|
|
const CefString& stringValue) {
|
|
JNI_CALL_VOID_METHOD(env, jstringRef, "set", "(Ljava/lang/String;)V",
|
|
NewJNIString(env, stringValue));
|
|
}
|
|
|
|
jstring NewJNIString(JNIEnv* env, const std::string& str) {
|
|
return env->NewStringUTF(str.c_str());
|
|
}
|
|
|
|
CefString GetJNIString(JNIEnv* env, jstring jstr) {
|
|
CefString cef_str;
|
|
const char* chr = nullptr;
|
|
if (jstr)
|
|
chr = env->GetStringUTFChars(jstr, nullptr);
|
|
if (chr)
|
|
cef_str = chr;
|
|
if (jstr)
|
|
env->ReleaseStringUTFChars(jstr, chr);
|
|
return cef_str;
|
|
}
|
|
|
|
jobjectArray NewJNIStringArray(JNIEnv* env,
|
|
const std::vector<CefString>& vals) {
|
|
if (vals.empty())
|
|
return nullptr;
|
|
|
|
ScopedJNIClass cls(env, "java/lang/String");
|
|
if (!cls)
|
|
return nullptr;
|
|
|
|
const jsize size = static_cast<jsize>(vals.size());
|
|
jobjectArray arr = env->NewObjectArray(size, cls, nullptr);
|
|
|
|
for (jsize i = 0; i < size; i++) {
|
|
ScopedJNIString str(env, vals[i]);
|
|
env->SetObjectArrayElement(arr, i, str);
|
|
}
|
|
|
|
return arr;
|
|
}
|
|
|
|
void GetJNIStringArray(JNIEnv* env,
|
|
jobjectArray jarray,
|
|
std::vector<CefString>& vals) {
|
|
jsize argc = env->GetArrayLength(jarray);
|
|
for (jsize i = 0; i < argc; ++i) {
|
|
ScopedJNIStringResult str(env,
|
|
(jstring)env->GetObjectArrayElement(jarray, i));
|
|
vals.push_back(str.GetCefString());
|
|
}
|
|
}
|
|
|
|
jobject NewJNIStringVector(JNIEnv* env, const std::vector<CefString>& vals) {
|
|
ScopedJNIObjectLocal jvector(env, "java/util/Vector");
|
|
if (!jvector)
|
|
return nullptr;
|
|
|
|
std::vector<CefString>::const_iterator iter;
|
|
for (iter = vals.begin(); iter != vals.end(); ++iter) {
|
|
AddJNIStringToVector(env, jvector, *iter);
|
|
}
|
|
return jvector.Release();
|
|
}
|
|
|
|
void AddJNIStringToVector(JNIEnv* env, jobject jvector, const CefString& str) {
|
|
ScopedJNIString argument(env, str);
|
|
JNI_CALL_VOID_METHOD(env, jvector, "addElement", "(Ljava/lang/Object;)V",
|
|
argument.get());
|
|
}
|
|
|
|
void GetJNIStringVector(JNIEnv* env,
|
|
jobject jvector,
|
|
std::vector<CefString>& vals) {
|
|
if (!jvector)
|
|
return;
|
|
|
|
jint jsize = 0;
|
|
JNI_CALL_METHOD(env, jvector, "size", "()I", Int, jsize);
|
|
|
|
for (jint index = 0; index < jsize; index++) {
|
|
ScopedJNIStringResult jstr(env);
|
|
JNI_CALL_METHOD(env, jvector, "get", "(I)Ljava/lang/Object;", Object, jstr,
|
|
index);
|
|
vals.push_back(jstr.GetCefString());
|
|
}
|
|
}
|
|
|
|
jobject NewJNIStringMap(JNIEnv* env,
|
|
const std::map<CefString, CefString>& vals) {
|
|
ScopedJNIObjectLocal jmap(env, "java/util/HashMap");
|
|
if (!jmap)
|
|
return nullptr;
|
|
|
|
for (auto iter = vals.begin(); iter != vals.end(); ++iter) {
|
|
ScopedJNIString jkey(env, iter->first);
|
|
ScopedJNIString jvalue(env, iter->second);
|
|
ScopedJNIObjectResult jresult(env);
|
|
JNI_CALL_METHOD(env, jmap, "put",
|
|
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
|
|
Object, jresult, jkey.get(), jvalue.get());
|
|
}
|
|
return jmap.Release();
|
|
}
|
|
|
|
void GetJNIStringMultiMap(JNIEnv* env,
|
|
jobject jheaderMap,
|
|
std::multimap<CefString, CefString>& vals) {
|
|
if (!jheaderMap)
|
|
return;
|
|
|
|
// public abstract java.util.Set<java.util.Map$Entry<K, V>> entrySet();
|
|
ScopedJNIObjectResult jentrySet(env);
|
|
JNI_CALL_METHOD(env, jheaderMap, "entrySet", "()Ljava/util/Set;", Object,
|
|
jentrySet);
|
|
if (!jentrySet)
|
|
return;
|
|
|
|
// public abstract java.lang.Object[] toArray();
|
|
ScopedJNIObjectResult jentrySetValues(env);
|
|
JNI_CALL_METHOD(env, jentrySet, "toArray", "()[Ljava/lang/Object;", Object,
|
|
jentrySetValues);
|
|
if (!jentrySetValues)
|
|
return;
|
|
|
|
jint length = env->GetArrayLength((jobjectArray)jentrySetValues.get());
|
|
for (jint i = 0; i < length; i++) {
|
|
ScopedJNIObjectLocal jmapEntry(
|
|
env,
|
|
env->GetObjectArrayElement((jobjectArray)jentrySetValues.get(), i));
|
|
if (!jmapEntry)
|
|
return;
|
|
ScopedJNIStringResult jkey(env);
|
|
ScopedJNIStringResult jvalue(env);
|
|
JNI_CALL_METHOD(env, jmapEntry, "getKey", "()Ljava/lang/Object;", Object,
|
|
jkey);
|
|
JNI_CALL_METHOD(env, jmapEntry, "getValue", "()Ljava/lang/Object;", Object,
|
|
jvalue);
|
|
vals.insert(std::make_pair(jkey.GetCefString(), jvalue.GetCefString()));
|
|
}
|
|
}
|
|
|
|
void SetJNIStringMultiMap(JNIEnv* env,
|
|
jobject jheaderMap,
|
|
const std::multimap<CefString, CefString>& vals) {
|
|
for (auto it = vals.begin(); it != vals.end(); ++it) {
|
|
ScopedJNIString jkey(env, it->first);
|
|
ScopedJNIString jvalue(env, it->second);
|
|
ScopedJNIObjectResult jresult(env);
|
|
JNI_CALL_METHOD(env, jheaderMap, "put",
|
|
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
|
|
Object, jresult, jkey.get(), jvalue.get());
|
|
}
|
|
}
|
|
|
|
void* GetJNIByteBufferData(JNIEnv* env, jobject jbyteBuffer) {
|
|
if (!jbyteBuffer)
|
|
return nullptr;
|
|
|
|
void* data = nullptr;
|
|
jlong capacity = env->GetDirectBufferCapacity(jbyteBuffer);
|
|
if (capacity > 0) {
|
|
data = env->GetDirectBufferAddress(jbyteBuffer);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
size_t GetJNIByteBufferLength(JNIEnv* env, jobject jbyteBuffer) {
|
|
if (!jbyteBuffer)
|
|
return 0;
|
|
|
|
return static_cast<size_t>(env->GetDirectBufferCapacity(jbyteBuffer));
|
|
}
|
|
|
|
CefMessageRouterConfig GetJNIMessageRouterConfig(JNIEnv* env, jobject jConfig) {
|
|
CefMessageRouterConfig config;
|
|
|
|
if (jConfig == nullptr)
|
|
return config;
|
|
ScopedJNIClass cls(env,
|
|
"org/cef/browser/CefMessageRouter$CefMessageRouterConfig");
|
|
if (cls == nullptr)
|
|
return config;
|
|
|
|
GetJNIFieldString(env, cls, jConfig, "jsQueryFunction",
|
|
&config.js_query_function);
|
|
GetJNIFieldString(env, cls, jConfig, "jsCancelFunction",
|
|
&config.js_cancel_function);
|
|
return config;
|
|
}
|
|
|
|
CefRefPtr<CefValue> GetCefValueFromJNIObject(JNIEnv* env, jobject obj) {
|
|
if (!obj)
|
|
return nullptr;
|
|
|
|
if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/lang/Boolean"))) {
|
|
return GetCefValueFromJNIBoolean(env, obj);
|
|
} else if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/lang/Integer"))) {
|
|
return GetCefValueFromJNIInteger(env, obj);
|
|
} else if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/lang/Double"))) {
|
|
return GetCefValueFromJNIDouble(env, obj);
|
|
} else if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/lang/String"))) {
|
|
return GetCefValueFromJNIString(env, obj);
|
|
} else if (env->IsInstanceOf(obj,
|
|
ScopedJNIClass(env, "java/nio/ByteBuffer"))) {
|
|
return GetCefValueFromJNIByteBuffer(env, obj);
|
|
} else if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/util/Map"))) {
|
|
return GetCefValueFromJNIMap(env, obj);
|
|
} else if (env->IsInstanceOf(obj, ScopedJNIClass(env, "java/util/List"))) {
|
|
return GetCefValueFromJNIList(env, obj);
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
CefRefPtr<CefValue> GetCefValueFromJNIBoolean(JNIEnv* env, const jobject& obj) {
|
|
CefRefPtr<CefValue> value = CefValue::Create();
|
|
value->SetBool(GetJNIBoolean(env, obj));
|
|
return value;
|
|
}
|
|
|
|
CefRefPtr<CefValue> GetCefValueFromJNIInteger(JNIEnv* env, const jobject& obj) {
|
|
CefRefPtr<CefValue> value = CefValue::Create();
|
|
value->SetInt(GetJNIInteger(env, obj));
|
|
return value;
|
|
}
|
|
|
|
CefRefPtr<CefValue> GetCefValueFromJNIDouble(JNIEnv* env, const jobject& obj) {
|
|
CefRefPtr<CefValue> value = CefValue::Create();
|
|
value->SetDouble(GetJNIDouble(env, obj));
|
|
return value;
|
|
}
|
|
|
|
CefRefPtr<CefValue> GetCefValueFromJNIString(JNIEnv* env, const jobject& obj) {
|
|
CefRefPtr<CefValue> value = CefValue::Create();
|
|
value->SetString(GetJNIString(env, static_cast<jstring>(obj)));
|
|
return value;
|
|
}
|
|
|
|
CefRefPtr<CefValue> GetCefValueFromJNIByteBuffer(JNIEnv* env,
|
|
const jobject& obj) {
|
|
CefRefPtr<CefValue> value = CefValue::Create();
|
|
CefRefPtr<CefBinaryValue> binary = CefBinaryValue::Create(
|
|
GetJNIByteBufferData(env, obj), GetJNIByteBufferLength(env, obj));
|
|
value->SetBinary(binary);
|
|
return value;
|
|
}
|
|
|
|
CefRefPtr<CefValue> GetCefValueFromJNIMap(JNIEnv* env, const jobject& obj) {
|
|
CefRefPtr<CefDictionaryValue> dict = CefDictionaryValue::Create();
|
|
|
|
ScopedJNIObjectResult entrySet(env);
|
|
JNI_CALL_METHOD(env, obj, "entrySet", "()Ljava/util/Set;", Object, entrySet);
|
|
|
|
ScopedJNIObjectResult iterator(env);
|
|
JNI_CALL_METHOD(env, entrySet, "iterator", "()Ljava/util/Iterator;", Object,
|
|
iterator);
|
|
|
|
jboolean hasNext = JNI_FALSE;
|
|
JNI_CALL_METHOD(env, iterator, "hasNext", "()Z", Boolean, hasNext);
|
|
|
|
while (hasNext == JNI_TRUE) {
|
|
ScopedJNIObjectResult next(env);
|
|
JNI_CALL_METHOD(env, iterator, "next", "()Ljava/lang/Object;", Object,
|
|
next);
|
|
|
|
ScopedJNIObjectResult entryKey(env);
|
|
JNI_CALL_METHOD(env, next, "getKey", "()Ljava/lang/Object;", Object,
|
|
entryKey);
|
|
CefString key = GetJNIString(env, static_cast<jstring>(entryKey.get()));
|
|
|
|
ScopedJNIObjectResult entryValue(env);
|
|
JNI_CALL_METHOD(env, next, "getValue", "()Ljava/lang/Object;", Object,
|
|
entryValue);
|
|
jobject jvalue = entryValue.get();
|
|
CefRefPtr<CefValue> cef_value = GetCefValueFromJNIObject(env, jvalue);
|
|
dict->SetValue(key, cef_value);
|
|
|
|
JNI_CALL_METHOD(env, iterator, "hasNext", "()Z", Boolean, hasNext);
|
|
}
|
|
|
|
CefRefPtr<CefValue> value = CefValue::Create();
|
|
return value;
|
|
}
|
|
|
|
CefRefPtr<CefValue> GetCefValueFromJNIList(JNIEnv* env, const jobject& obj) {
|
|
CefRefPtr<CefListValue> list = CefListValue::Create();
|
|
|
|
ScopedJNIObjectResult iterator(env);
|
|
JNI_CALL_METHOD(env, obj, "iterator", "()Ljava/util/Iterator;", Object,
|
|
iterator);
|
|
|
|
jboolean hasNext = JNI_FALSE;
|
|
JNI_CALL_METHOD(env, iterator, "hasNext", "()Z", Boolean, hasNext);
|
|
|
|
long index = 0;
|
|
while (hasNext == JNI_TRUE) {
|
|
ScopedJNIObjectResult next(env);
|
|
JNI_CALL_METHOD(env, iterator, "next", "()Ljava/lang/Object;", Object,
|
|
next);
|
|
jobject jvalue = next.get();
|
|
CefRefPtr<CefValue> cef_value = GetCefValueFromJNIObject(env, jvalue);
|
|
list->SetValue(index, cef_value);
|
|
index++;
|
|
JNI_CALL_METHOD(env, iterator, "hasNext", "()Z", Boolean, hasNext);
|
|
}
|
|
|
|
CefRefPtr<CefValue> value = CefValue::Create();
|
|
value->SetList(list);
|
|
return value;
|
|
}
|
|
|
|
jobject NewJNIErrorCode(JNIEnv* env, cef_errorcode_t errorCode) {
|
|
ScopedJNIObjectResult jerrorCode(env);
|
|
switch (errorCode) {
|
|
default:
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_NONE,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_IO_PENDING,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_FAILED,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_ABORTED,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INVALID_ARGUMENT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INVALID_HANDLE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_FILE_NOT_FOUND, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_TIMED_OUT,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_FILE_TOO_BIG, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_UNEXPECTED,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_ACCESS_DENIED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_NOT_IMPLEMENTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INSUFFICIENT_RESOURCES, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_OUT_OF_MEMORY, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_UPLOAD_FILE_CHANGED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SOCKET_NOT_CONNECTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_FILE_EXISTS,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_FILE_PATH_TOO_LONG, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_FILE_NO_SPACE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_FILE_VIRUS_INFECTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_BLOCKED_BY_CLIENT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_NETWORK_CHANGED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_BLOCKED_BY_ADMINISTRATOR, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SOCKET_IS_CONNECTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_UPLOAD_STREAM_REWIND_NOT_SUPPORTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CONTEXT_SHUT_DOWN, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_BLOCKED_BY_RESPONSE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CLEARTEXT_NOT_PERMITTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CONNECTION_CLOSED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CONNECTION_RESET, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CONNECTION_REFUSED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CONNECTION_ABORTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CONNECTION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_NAME_NOT_RESOLVED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INTERNET_DISCONNECTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_PROTOCOL_ERROR, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_ADDRESS_INVALID, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_ADDRESS_UNREACHABLE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_CLIENT_AUTH_CERT_NEEDED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_TUNNEL_CONNECTION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_NO_SSL_VERSIONS_ENABLED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_VERSION_OR_CIPHER_MISMATCH, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_RENEGOTIATION_REQUESTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PROXY_AUTH_UNSUPPORTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_BAD_SSL_CLIENT_AUTH_CERT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CONNECTION_TIMED_OUT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SOCKS_CONNECTION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SOCKS_CONNECTION_HOST_UNREACHABLE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_ALPN_NEGOTIATION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_NO_RENEGOTIATION, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_DECOMPRESSION_FAILURE_ALERT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_BAD_RECORD_MAC_ALERT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PROXY_AUTH_REQUESTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PROXY_CONNECTION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_MANDATORY_PROXY_CONFIGURATION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PRECONNECT_MAX_SOCKET_LIMIT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PROXY_CERTIFICATE_INVALID, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_NAME_RESOLUTION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_NETWORK_ACCESS_DENIED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_TEMPORARILY_THROTTLED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_MSG_TOO_BIG,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_WS_PROTOCOL_ERROR, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_ADDRESS_IN_USE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_HANDSHAKE_NOT_COMPLETED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_BAD_PEER_PUBLIC_KEY, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CLIENT_AUTH_CERT_TYPE_UNSUPPORTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_DECRYPT_ERROR_ALERT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_WS_THROTTLE_QUEUE_TOO_LARGE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_SERVER_CERT_CHANGED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_UNRECOGNIZED_NAME_ALERT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SOCKET_SET_RECEIVE_BUFFER_SIZE_ERROR, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SOCKET_SET_SEND_BUFFER_SIZE_ERROR, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_CLIENT_AUTH_CERT_BAD_FORMAT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_ICANN_NAME_COLLISION, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_SERVER_CERT_BAD_FORMAT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CT_STH_PARSING_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CT_STH_INCOMPLETE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_UNABLE_TO_REUSE_CONNECTION_FOR_PROXY_AUTH, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CT_CONSISTENCY_PROOF_PARSING_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_OBSOLETE_CIPHER, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_WS_UPGRADE,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_READ_IF_READY_NOT_IMPLEMENTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_NO_BUFFER_SPACE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_CLIENT_AUTH_NO_COMMON_ALGORITHMS, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_EARLY_DATA_REJECTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_WRONG_VERSION_ON_EARLY_DATA, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_TLS13_DOWNGRADE_DETECTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SSL_KEY_USAGE_INCOMPATIBLE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INVALID_ECH_CONFIG_LIST, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_ECH_NOT_NEGOTIATED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_ECH_FALLBACK_CERTIFICATE_INVALID, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_COMMON_NAME_INVALID, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_DATE_INVALID, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_AUTHORITY_INVALID, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_CONTAINS_ERRORS, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_NO_REVOCATION_MECHANISM, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_UNABLE_TO_CHECK_REVOCATION, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_REVOKED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_INVALID, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_WEAK_SIGNATURE_ALGORITHM, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_NON_UNIQUE_NAME, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_WEAK_KEY, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_NAME_CONSTRAINT_VIOLATION, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_VALIDITY_TOO_LONG, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERTIFICATE_TRANSPARENCY_REQUIRED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_KNOWN_INTERCEPTION_BLOCKED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_CERT_END,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_INVALID_URL,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_DISALLOWED_URL_SCHEME, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_UNKNOWN_URL_SCHEME, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INVALID_REDIRECT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_TOO_MANY_REDIRECTS, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_UNSAFE_REDIRECT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_UNSAFE_PORT,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INVALID_RESPONSE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INVALID_CHUNKED_ENCODING, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_METHOD_NOT_SUPPORTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_UNEXPECTED_PROXY_AUTH, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_EMPTY_RESPONSE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_RESPONSE_HEADERS_TOO_BIG, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PAC_SCRIPT_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_REQUEST_RANGE_NOT_SATISFIABLE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_MALFORMED_IDENTITY, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CONTENT_DECODING_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_NETWORK_IO_SUSPENDED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SYN_REPLY_NOT_RECEIVED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_ENCODING_CONVERSION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_UNRECOGNIZED_FTP_DIRECTORY_LISTING_FORMAT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_NO_SUPPORTED_PROXIES, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTP2_PROTOCOL_ERROR, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INVALID_AUTH_CREDENTIALS, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_UNSUPPORTED_AUTH_SCHEME, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_ENCODING_DETECTION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_MISSING_AUTH_CREDENTIALS, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_UNEXPECTED_SECURITY_LIBRARY_STATUS, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_MISCONFIGURED_AUTH_ENVIRONMENT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_UNDOCUMENTED_SECURITY_LIBRARY_STATUS, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_RESPONSE_BODY_TOO_BIG_TO_DRAIN, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INCOMPLETE_HTTP2_HEADERS, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PAC_NOT_IN_DHCP, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTP2_SERVER_REFUSED_STREAM, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTP2_PING_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CONTENT_LENGTH_MISMATCH, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INCOMPLETE_CHUNKED_ENCODING, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_QUIC_PROTOCOL_ERROR, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_RESPONSE_HEADERS_TRUNCATED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_QUIC_HANDSHAKE_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTP2_INADEQUATE_TRANSPORT_SECURITY, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTP2_FLOW_CONTROL_ERROR, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTP2_FRAME_SIZE_ERROR, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTP2_COMPRESSION_ERROR, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTP_1_1_REQUIRED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PROXY_HTTP_1_1_REQUIRED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PAC_SCRIPT_TERMINATED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INVALID_HTTP_RESPONSE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CONTENT_DECODING_INIT_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTP2_RST_STREAM_NO_ERROR_RECEIVED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_TOO_MANY_RETRIES, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTP2_STREAM_CLOSED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_HTTP_RESPONSE_CODE_FAILURE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_QUIC_CERT_ROOT_NOT_KNOWN, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_QUIC_GOAWAY_REQUEST_CAN_BE_RETRIED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_CACHE_MISS,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_READ_FAILURE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_WRITE_FAILURE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_OPERATION_NOT_SUPPORTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_OPEN_FAILURE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_CREATE_FAILURE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode", ERR_CACHE_RACE,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_CHECKSUM_READ_FAILURE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_CHECKSUM_MISMATCH, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_LOCK_TIMEOUT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_AUTH_FAILURE_AFTER_READ, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_ENTRY_NOT_SUITABLE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_DOOM_FAILURE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CACHE_OPEN_OR_CREATE_FAILURE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INSECURE_RESPONSE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_NO_PRIVATE_KEY_FOR_CERT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_ADD_USER_CERT_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INVALID_SIGNED_EXCHANGE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_INVALID_WEB_BUNDLE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_TRUST_TOKEN_OPERATION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_TRUST_TOKEN_OPERATION_SUCCESS_WITHOUT_SENDING_REQUEST,
|
|
jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PKCS12_IMPORT_BAD_PASSWORD, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PKCS12_IMPORT_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_IMPORT_CA_CERT_NOT_CA, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_IMPORT_CERT_ALREADY_EXISTS, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_IMPORT_CA_CERT_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_IMPORT_SERVER_CERT_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PKCS12_IMPORT_INVALID_MAC, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PKCS12_IMPORT_INVALID_FILE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PKCS12_IMPORT_UNSUPPORTED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_KEY_GENERATION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_PRIVATE_KEY_EXPORT_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_SELF_SIGNED_CERT_GENERATION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_CERT_DATABASE_CHANGED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_DNS_MALFORMED_RESPONSE, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_DNS_SERVER_REQUIRES_TCP, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_DNS_SERVER_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_DNS_TIMED_OUT, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_DNS_CACHE_MISS, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_DNS_SEARCH_EMPTY, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_DNS_SORT_ERROR, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_DNS_SECURE_RESOLVER_HOSTNAME_RESOLUTION_FAILED, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_DNS_NAME_HTTPS_ONLY, jerrorCode);
|
|
JNI_CASE(env, "org/cef/handler/CefLoadHandler$ErrorCode",
|
|
ERR_DNS_REQUEST_CANCELLED, jerrorCode);
|
|
}
|
|
return jerrorCode.Release();
|
|
}
|
|
|
|
jobject NewJNIBoolean(JNIEnv* env, const bool value) {
|
|
ScopedJNIClass cls(env, "java/lang/Boolean");
|
|
if (!cls)
|
|
return nullptr;
|
|
|
|
jmethodID method =
|
|
env->GetStaticMethodID(cls, "valueOf", "(Z)Ljava/lang/Boolean;");
|
|
if (!method)
|
|
return nullptr;
|
|
|
|
return env->CallStaticObjectMethod(cls, method, value ? JNI_TRUE : JNI_FALSE);
|
|
}
|
|
|
|
jboolean GetJNIBoolean(JNIEnv* env, jobject obj) {
|
|
if (obj) {
|
|
jboolean value = JNI_FALSE;
|
|
JNI_CALL_METHOD(env, obj, "booleanValue", "()Z", Boolean, value);
|
|
return value;
|
|
}
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
jobject NewJNIInteger(JNIEnv* env, const int value) {
|
|
ScopedJNIClass cls(env, "java/lang/Integer");
|
|
if (!cls)
|
|
return nullptr;
|
|
|
|
jmethodID method =
|
|
env->GetStaticMethodID(cls, "valueOf", "(I)Ljava/lang/Integer;");
|
|
if (!method)
|
|
return nullptr;
|
|
|
|
return env->CallStaticObjectMethod(cls, method, value);
|
|
}
|
|
|
|
jint GetJNIInteger(JNIEnv* env, jobject obj) {
|
|
if (obj) {
|
|
jint value = 0;
|
|
JNI_CALL_METHOD(env, obj, "intValue", "()I", Int, value);
|
|
return value;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
jobject NewJNIDouble(JNIEnv* env, const double value) {
|
|
ScopedJNIClass cls(env, "java/lang/Double");
|
|
if (!cls)
|
|
return nullptr;
|
|
|
|
jmethodID method =
|
|
env->GetStaticMethodID(cls, "valueOf", "(D)Ljava/lang/Double;");
|
|
if (!method)
|
|
return nullptr;
|
|
|
|
return env->CallStaticObjectMethod(cls, method, value);
|
|
}
|
|
|
|
jdouble GetJNIDouble(JNIEnv* env, jobject obj) {
|
|
if (obj) {
|
|
jdouble value = 0;
|
|
JNI_CALL_METHOD(env, obj, "doubleValue", "()D", Double, value);
|
|
return value;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
jobject NewJNIByteBuffer(JNIEnv* env, const void* data, size_t size) {
|
|
ScopedJNIClass cls(env, "java/nio/ByteBuffer");
|
|
if (!cls)
|
|
return nullptr;
|
|
|
|
jmethodID method =
|
|
env->GetStaticMethodID(cls, "wrap", "([B)Ljava/nio/ByteBuffer;");
|
|
if (!method)
|
|
return nullptr;
|
|
|
|
jbyteArray array = env->NewByteArray((jsize)size);
|
|
if (!array)
|
|
return nullptr;
|
|
|
|
env->SetByteArrayRegion(array, 0, (jsize)size,
|
|
reinterpret_cast<const jbyte*>(data));
|
|
return env->CallStaticObjectMethod(cls, method, array);
|
|
}
|
|
|
|
jobject NewJNIHashMap(JNIEnv* env) {
|
|
ScopedJNIClass cls(env, "java/util/HashMap");
|
|
if (!cls)
|
|
return nullptr;
|
|
|
|
jmethodID method = env->GetMethodID(cls, "<init>", "()V");
|
|
if (!method)
|
|
return nullptr;
|
|
|
|
return env->NewObject(cls, method);
|
|
}
|
|
|
|
jobject NewJNIArrayList(JNIEnv* env) {
|
|
ScopedJNIClass cls(env, "java/util/ArrayList");
|
|
if (!cls)
|
|
return nullptr;
|
|
|
|
jmethodID method = env->GetMethodID(cls, "<init>", "()V");
|
|
if (!method)
|
|
return nullptr;
|
|
|
|
return env->NewObject(cls, method);
|
|
}
|
|
|
|
jobject NewJNIObjectFromCefValue(JNIEnv* env, const CefRefPtr<CefValue> value) {
|
|
switch (value->GetType()) {
|
|
case VTYPE_NULL:
|
|
return nullptr;
|
|
case VTYPE_BOOL:
|
|
return NewJNIBoolean(env, value->GetBool());
|
|
case VTYPE_INT:
|
|
return NewJNIInteger(env, value->GetInt());
|
|
case VTYPE_DOUBLE:
|
|
return NewJNIDouble(env, value->GetDouble());
|
|
case VTYPE_STRING:
|
|
return NewJNIString(env, value->GetString());
|
|
case VTYPE_BINARY:
|
|
return NewJNIByteBuffer(env, value->GetBinary()->GetRawData(),
|
|
value->GetBinary()->GetSize());
|
|
case VTYPE_DICTIONARY: {
|
|
jobject jmap = NewJNIHashMap(env);
|
|
CefRefPtr<CefDictionaryValue> dict = value->GetDictionary();
|
|
CefDictionaryValue::KeyList keys;
|
|
dict->GetKeys(keys);
|
|
for (const CefString& key : keys) {
|
|
jstring jkey = NewJNIString(env, key);
|
|
jobject jvalue = NewJNIObjectFromCefValue(env, dict->GetValue(key));
|
|
JNI_CALL_VOID_METHOD(
|
|
env, jmap, "put",
|
|
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", jkey,
|
|
jvalue);
|
|
}
|
|
return jmap;
|
|
}
|
|
case VTYPE_LIST: {
|
|
jobject jlist = NewJNIArrayList(env);
|
|
CefRefPtr<CefListValue> list = value->GetList();
|
|
const size_t size = list->GetSize();
|
|
for (size_t i = 0; i < size; ++i) {
|
|
jobject jvalue = NewJNIObjectFromCefValue(env, list->GetValue(i));
|
|
JNI_CALL_VOID_METHOD(env, jlist, "add", "(Ljava/lang/Object;)Z",
|
|
jvalue);
|
|
}
|
|
return jlist;
|
|
}
|
|
default:
|
|
NOTREACHED();
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
cef_errorcode_t GetJNIErrorCode(JNIEnv* env, jobject jerrorCode) {
|
|
cef_errorcode_t errorCode = ERR_NONE;
|
|
|
|
if (jerrorCode) {
|
|
jint jcode = 0;
|
|
JNI_CALL_METHOD(env, jerrorCode, "getCode", "()I", Int, jcode);
|
|
errorCode = static_cast<cef_errorcode_t>(jcode);
|
|
}
|
|
|
|
return errorCode;
|
|
}
|
|
|
|
bool GetJNIFieldObject(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* field_name,
|
|
jobject* value,
|
|
const char* object_type) {
|
|
jfieldID field = env->GetFieldID(cls, field_name, object_type);
|
|
if (field) {
|
|
*value = env->GetObjectField(obj, field);
|
|
return *value != nullptr;
|
|
}
|
|
env->ExceptionClear();
|
|
return false;
|
|
}
|
|
|
|
bool GetJNIFieldString(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* field_name,
|
|
CefString* value) {
|
|
jobject fieldobj = nullptr;
|
|
if (GetJNIFieldObject(env, cls, obj, field_name, &fieldobj,
|
|
"Ljava/lang/String;")) {
|
|
ScopedJNIStringResult str(env, (jstring)fieldobj);
|
|
*value = str.GetCefString();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool GetJNIFieldDate(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* field_name,
|
|
CefBaseTime* value) {
|
|
jobject fieldobj = nullptr;
|
|
if (GetJNIFieldObject(env, cls, obj, field_name, &fieldobj,
|
|
"Ljava/util/Date;")) {
|
|
ScopedJNIObjectLocal jdate(env, fieldobj);
|
|
long timestamp = 0;
|
|
JNI_CALL_METHOD(env, jdate, "getTime", "()J", Long, timestamp);
|
|
CefTime cef_time;
|
|
cef_time.SetDoubleT((double)(timestamp / 1000));
|
|
cef_time_to_basetime(&cef_time, value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool GetJNIFieldBoolean(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* field_name,
|
|
int* value) {
|
|
jfieldID field = env->GetFieldID(cls, field_name, "Z");
|
|
if (field) {
|
|
*value = env->GetBooleanField(obj, field) != JNI_FALSE ? 1 : 0;
|
|
return true;
|
|
}
|
|
env->ExceptionClear();
|
|
return false;
|
|
}
|
|
|
|
bool GetJNIFieldDouble(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* field_name,
|
|
double* value) {
|
|
jfieldID field = env->GetFieldID(cls, field_name, "D");
|
|
if (field) {
|
|
*value = env->GetDoubleField(obj, field);
|
|
return true;
|
|
}
|
|
env->ExceptionClear();
|
|
return false;
|
|
}
|
|
|
|
bool GetJNIFieldInt(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* field_name,
|
|
int* value) {
|
|
jfieldID field = env->GetFieldID(cls, field_name, "I");
|
|
if (field) {
|
|
*value = env->GetIntField(obj, field);
|
|
return true;
|
|
}
|
|
env->ExceptionClear();
|
|
return false;
|
|
}
|
|
|
|
bool GetJNIFieldLong(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* field_name,
|
|
jlong* value) {
|
|
jfieldID field = env->GetFieldID(cls, field_name, "J");
|
|
if (field) {
|
|
*value = env->GetLongField(obj, field);
|
|
return true;
|
|
}
|
|
env->ExceptionClear();
|
|
return false;
|
|
}
|
|
|
|
bool SetJNIFieldInt(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* field_name,
|
|
int value) {
|
|
jfieldID field = env->GetFieldID(cls, field_name, "I");
|
|
if (field) {
|
|
env->SetIntField(obj, field, value);
|
|
return true;
|
|
}
|
|
env->ExceptionClear();
|
|
return false;
|
|
}
|
|
|
|
bool SetJNIFieldDouble(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* field_name,
|
|
double value) {
|
|
jfieldID field = env->GetFieldID(cls, field_name, "D");
|
|
if (field) {
|
|
env->SetDoubleField(obj, field, value);
|
|
return true;
|
|
}
|
|
env->ExceptionClear();
|
|
return false;
|
|
}
|
|
|
|
bool SetJNIFieldBoolean(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* field_name,
|
|
int value) {
|
|
jfieldID field = env->GetFieldID(cls, field_name, "Z");
|
|
if (field) {
|
|
env->SetBooleanField(obj, field, value == 0 ? 0 : 1);
|
|
return true;
|
|
}
|
|
env->ExceptionClear();
|
|
return false;
|
|
}
|
|
|
|
bool GetJNIFieldStaticInt(JNIEnv* env,
|
|
jclass cls,
|
|
const char* field_name,
|
|
int* value) {
|
|
jfieldID field = env->GetStaticFieldID(cls, field_name, "I");
|
|
if (field) {
|
|
*value = env->GetStaticIntField(cls, field);
|
|
return true;
|
|
}
|
|
env->ExceptionClear();
|
|
return false;
|
|
}
|
|
|
|
bool CallJNIMethodI_V(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* method_name,
|
|
int* value) {
|
|
jmethodID methodID = env->GetMethodID(cls, method_name, "()I");
|
|
if (methodID) {
|
|
*value = env->CallIntMethod(obj, methodID);
|
|
return true;
|
|
}
|
|
env->ExceptionClear();
|
|
return false;
|
|
}
|
|
|
|
bool CallJNIMethodC_V(JNIEnv* env,
|
|
jclass cls,
|
|
jobject obj,
|
|
const char* method_name,
|
|
char16_t* value) {
|
|
jmethodID methodID = env->GetMethodID(cls, method_name, "()C");
|
|
if (methodID) {
|
|
*value = env->CallCharMethod(obj, methodID);
|
|
return true;
|
|
}
|
|
env->ExceptionClear();
|
|
return false;
|
|
}
|
|
|
|
CefSize GetJNISize(JNIEnv* env, jobject obj) {
|
|
CefSize size;
|
|
|
|
ScopedJNIClass cls(env, "java/awt/Dimension");
|
|
if (!cls)
|
|
return size;
|
|
|
|
int width, height;
|
|
if (GetJNIFieldInt(env, cls, obj, "width", &width) &&
|
|
GetJNIFieldInt(env, cls, obj, "height", &height)) {
|
|
size.Set(width, height);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
CefRect GetJNIRect(JNIEnv* env, jobject obj) {
|
|
CefRect rect;
|
|
|
|
ScopedJNIClass cls(env, "java/awt/Rectangle");
|
|
if (!cls)
|
|
return rect;
|
|
|
|
int x, y, width, height;
|
|
if (GetJNIFieldInt(env, cls, obj, "x", &x) &&
|
|
GetJNIFieldInt(env, cls, obj, "y", &y) &&
|
|
GetJNIFieldInt(env, cls, obj, "width", &width) &&
|
|
GetJNIFieldInt(env, cls, obj, "height", &height)) {
|
|
rect.Set(x, y, width, height);
|
|
return rect;
|
|
}
|
|
|
|
return rect;
|
|
}
|
|
|
|
bool GetJNIPoint(JNIEnv* env, jobject obj, int* x, int* y) {
|
|
ScopedJNIClass cls(env, "java/awt/Point");
|
|
if (!cls)
|
|
return false;
|
|
|
|
if (GetJNIFieldInt(env, cls, obj, "x", x) &&
|
|
GetJNIFieldInt(env, cls, obj, "y", y)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
CefRefPtr<CefBrowser> GetJNIBrowser(JNIEnv* env, jobject jbrowser) {
|
|
return GetCefFromJNIObject<CefBrowser>(env, jbrowser, "CefBrowser");
|
|
}
|
|
|
|
jobject GetJNIEnumValue(JNIEnv* env,
|
|
const char* class_name,
|
|
const char* enum_valname) {
|
|
ScopedJNIClass cls(env, class_name);
|
|
if (!cls)
|
|
return nullptr;
|
|
|
|
std::string tmp;
|
|
tmp.append("L").append(class_name).append(";");
|
|
|
|
jfieldID fieldId = env->GetStaticFieldID(cls, enum_valname, tmp.c_str());
|
|
if (!fieldId)
|
|
return nullptr;
|
|
|
|
return env->GetStaticObjectField(cls, fieldId);
|
|
}
|
|
|
|
bool IsJNIEnumValue(JNIEnv* env,
|
|
jobject jenum,
|
|
const char* class_name,
|
|
const char* enum_valname) {
|
|
if (!jenum)
|
|
return false;
|
|
|
|
ScopedJNIObjectLocal compareTo(
|
|
env, GetJNIEnumValue(env, class_name, enum_valname));
|
|
if (compareTo) {
|
|
jboolean isEqual = JNI_FALSE;
|
|
JNI_CALL_METHOD(env, jenum, "equals", "(Ljava/lang/Object;)Z", Boolean,
|
|
isEqual, compareTo.get());
|
|
return (isEqual != JNI_FALSE);
|
|
}
|
|
return false;
|
|
}
|