Store InputStreamReader charset name and recreate Decoder per call

Author: dlunch

java_runtime/src/classes/java/io/input_stream_reader.rs

@@ -1,13 +1,12 @@
 use core::cmp::min;
 
-use alloc::{sync::Arc, vec};
+use alloc::vec;
 
 use bytemuck::{cast_slice, cast_vec};
-use encoding_rs::{Decoder, EUC_KR, UTF_8};
-use parking_lot::Mutex;
+use encoding_rs::{EUC_KR, UTF_8};
 
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
-use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result};
+use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
 
 use crate::{
     RuntimeClassProto, RuntimeContext,
@@ -36,7 +35,7 @@ impl InputStreamReader {
                 JavaFieldProto::new("readBufSize", "I", Default::default()),
                 JavaFieldProto::new("writeBuf", "[C", Default::default()),
                 JavaFieldProto::new("writeBufSize", "I", Default::default()),
-                JavaFieldProto::new("decoder", "[B", Default::default()),
+                JavaFieldProto::new("charset", "Ljava/lang/String;", Default::default()),
             ],
             access_flags: Default::default(),
         }
@@ -48,16 +47,8 @@ impl InputStreamReader {
         let _: () = jvm.invoke_special(&this, "java/io/Reader", "<init>", "()V", ()).await?;
 
         let charset = System::get_charset(jvm).await?;
-
-        let decoder = if charset == "UTF-8" {
-            UTF_8.new_decoder()
-        } else if charset == "EUC-KR" {
-            EUC_KR.new_decoder()
-        } else {
-            unimplemented!("unsupported charset: {}", charset)
-        };
-
-        jvm.put_rust_object_field(&mut this, "decoder", Arc::new(Mutex::new(decoder))).await?;
+        let charset_java = JavaLangString::from_rust_string(jvm, &charset).await?;
+        jvm.put_field(&mut this, "charset", "Ljava/lang/String;", charset_java).await?;
 
         let read_buf = jvm.instantiate_array("B", BUF_SIZE).await?;
         jvm.put_field(&mut this, "readBuf", "[B", read_buf).await?;
@@ -114,10 +105,18 @@ impl InputStreamReader {
             let mut read_buf_data = vec![0; read_buf_size as _];
             jvm.array_raw_buffer(&read_buf).await?.read(0, &mut read_buf_data).unwrap();
 
-            let decoder: Arc<Mutex<Decoder>> = jvm.get_rust_object_field(&this, "decoder").await?;
+            let charset_ref = jvm.get_field(&this, "charset", "Ljava/lang/String;").await?;
+            let charset = JavaLangString::to_rust_string(jvm, &charset_ref).await?;
+            let mut decoder = if charset == "UTF-8" {
+                UTF_8.new_decoder_without_bom_handling()
+            } else if charset == "EUC-KR" {
+                EUC_KR.new_decoder_without_bom_handling()
+            } else {
+                unimplemented!("unsupported charset: {}", charset)
+            };
 
             let mut decoded = vec![0; BUF_SIZE * 3];
-            let (_, read, wrote, _) = decoder.lock().decode_to_utf16(&cast_vec(read_buf_data), &mut decoded, false);
+            let (_, read, wrote, _) = decoder.decode_to_utf16(&cast_vec(read_buf_data), &mut decoded, false);
 
             // advance readBuf
             let _: () = jvm