1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/android/jni_string.h"
6
7 #include <string_view>
8
9 #include "base/android/jni_android.h"
10 #include "base/logging.h"
11 #include "base/numerics/safe_conversions.h"
12 #include "base/strings/utf_string_conversions.h"
13
14 // Size of buffer to allocate on the stack for string conversion.
15 #define BUFFER_SIZE 1024
16
17 namespace {
18
19 // Internal version that does not use a scoped local pointer.
ConvertUTF16ToJavaStringImpl(JNIEnv * env,std::u16string_view str)20 jstring ConvertUTF16ToJavaStringImpl(JNIEnv* env, std::u16string_view str) {
21 jstring result = env->NewString(reinterpret_cast<const jchar*>(str.data()),
22 base::checked_cast<jsize>(str.length()));
23 base::android::CheckException(env);
24 return result;
25 }
26
27 } // namespace
28
29 namespace base {
30 namespace android {
31
ConvertJavaStringToUTF8(JNIEnv * env,jstring str,std::string * result)32 void ConvertJavaStringToUTF8(JNIEnv* env, jstring str, std::string* result) {
33 DCHECK(str);
34 if (!str) {
35 LOG(WARNING) << "ConvertJavaStringToUTF8 called with null string.";
36 result->clear();
37 return;
38 }
39 const jsize length = env->GetStringLength(str);
40 if (length <= 0) {
41 result->clear();
42 CheckException(env);
43 return;
44 }
45 // JNI's GetStringUTFChars() and GetStringUTFRegion returns strings in Java
46 // "modified" UTF8, so instead get the String in UTF16 and convert using
47 // chromium's conversion function that yields plain (non Java-modified) UTF8.
48 if (length <= BUFFER_SIZE) {
49 // fast path, allocate temporary buffer on the stack and use GetStringRegion
50 // to copy the utf-16 characters into it with no heap allocation.
51 // https://developer.android.com/training/articles/perf-jni#utf-8-and-utf-16-strings:~:text=stack%2Dallocated%20buffer
52 std::array<jchar, BUFFER_SIZE> chars;
53 // GetStringRegion does not copy a null terminated string so the length must
54 // be explicitly passed to UTF16ToUTF8.
55 env->GetStringRegion(str, 0, length, chars.data());
56 UTF16ToUTF8(reinterpret_cast<const char16_t*>(chars.data()),
57 static_cast<size_t>(length), result);
58 } else {
59 // slow path
60 // GetStringChars doesn't NULL-terminate the strings it returns, so the
61 // length must be explicitly passed to UTF16ToUTF8.
62 const jchar* chars = env->GetStringChars(str, NULL);
63 DCHECK(chars);
64 UTF16ToUTF8(reinterpret_cast<const char16_t*>(chars),
65 static_cast<size_t>(length), result);
66 env->ReleaseStringChars(str, chars);
67 }
68 CheckException(env);
69 }
70
ConvertJavaStringToUTF8(JNIEnv * env,jstring str)71 std::string ConvertJavaStringToUTF8(JNIEnv* env, jstring str) {
72 std::string result;
73 ConvertJavaStringToUTF8(env, str, &result);
74 return result;
75 }
76
ConvertJavaStringToUTF8(const JavaRef<jstring> & str)77 std::string ConvertJavaStringToUTF8(const JavaRef<jstring>& str) {
78 return ConvertJavaStringToUTF8(AttachCurrentThread(), str.obj());
79 }
80
ConvertJavaStringToUTF8(JNIEnv * env,const JavaRef<jstring> & str)81 std::string ConvertJavaStringToUTF8(JNIEnv* env, const JavaRef<jstring>& str) {
82 return ConvertJavaStringToUTF8(env, str.obj());
83 }
84
ConvertUTF8ToJavaString(JNIEnv * env,std::string_view str)85 ScopedJavaLocalRef<jstring> ConvertUTF8ToJavaString(JNIEnv* env,
86 std::string_view str) {
87 // JNI's NewStringUTF expects "modified" UTF8 so instead create the string
88 // via our own UTF16 conversion utility.
89 // Further, Dalvik requires the string passed into NewStringUTF() to come from
90 // a trusted source. We can't guarantee that all UTF8 will be sanitized before
91 // it gets here, so constructing via UTF16 side-steps this issue.
92 // (Dalvik stores strings internally as UTF16 anyway, so there shouldn't be
93 // a significant performance hit by doing it this way).
94 return ScopedJavaLocalRef<jstring>(env, ConvertUTF16ToJavaStringImpl(
95 env, UTF8ToUTF16(str)));
96 }
97
ConvertJavaStringToUTF16(JNIEnv * env,jstring str,std::u16string * result)98 void ConvertJavaStringToUTF16(JNIEnv* env,
99 jstring str,
100 std::u16string* result) {
101 DCHECK(str);
102 if (!str) {
103 LOG(WARNING) << "ConvertJavaStringToUTF16 called with null string.";
104 result->clear();
105 return;
106 }
107 const jsize length = env->GetStringLength(str);
108 if (length <= 0) {
109 result->clear();
110 CheckException(env);
111 return;
112 }
113 if (length <= BUFFER_SIZE) {
114 // fast path, allocate temporary buffer on the stack and use GetStringRegion
115 // to copy the utf-16 characters into it with no heap allocation.
116 // https://developer.android.com/training/articles/perf-jni#utf-8-and-utf-16-strings:~:text=stack%2Dallocated%20buffer
117 std::array<jchar, BUFFER_SIZE> chars;
118 env->GetStringRegion(str, 0, length, chars.data());
119 // GetStringRegion does not copy a null terminated string so the length must
120 // be explicitly passed to assign.
121 result->assign(reinterpret_cast<const char16_t*>(chars.data()),
122 static_cast<size_t>(length));
123 } else {
124 // slow path
125 const jchar* chars = env->GetStringChars(str, NULL);
126 DCHECK(chars);
127 // GetStringChars doesn't NULL-terminate the strings it returns, so the
128 // length must be explicitly passed to assign.
129 result->assign(reinterpret_cast<const char16_t*>(chars),
130 static_cast<size_t>(length));
131 env->ReleaseStringChars(str, chars);
132 }
133 CheckException(env);
134 }
135
ConvertJavaStringToUTF16(JNIEnv * env,jstring str)136 std::u16string ConvertJavaStringToUTF16(JNIEnv* env, jstring str) {
137 std::u16string result;
138 ConvertJavaStringToUTF16(env, str, &result);
139 return result;
140 }
141
ConvertJavaStringToUTF16(const JavaRef<jstring> & str)142 std::u16string ConvertJavaStringToUTF16(const JavaRef<jstring>& str) {
143 return ConvertJavaStringToUTF16(AttachCurrentThread(), str.obj());
144 }
145
ConvertJavaStringToUTF16(JNIEnv * env,const JavaRef<jstring> & str)146 std::u16string ConvertJavaStringToUTF16(JNIEnv* env,
147 const JavaRef<jstring>& str) {
148 return ConvertJavaStringToUTF16(env, str.obj());
149 }
150
ConvertUTF16ToJavaString(JNIEnv * env,std::u16string_view str)151 ScopedJavaLocalRef<jstring> ConvertUTF16ToJavaString(JNIEnv* env,
152 std::u16string_view str) {
153 return ScopedJavaLocalRef<jstring>(env,
154 ConvertUTF16ToJavaStringImpl(env, str));
155 }
156
157 } // namespace android
158 } // namespace base
159