JBR-9817 Wayland: text-input-unstable-v3: Japanese input text partially highlighted in search

* Completely reimplementing JavaPreeditString#fromWaylandPreeditString and JavaCommitString#fromWaylandCommitString to make sure they don't ignore UTF-8 encoding errors and that JavaPreeditString#fromWaylandPreeditString sensibly handles invalid cursor indices.
* Covering the new JavaPreeditString#fromWaylandPreeditString with tests.
* Working around https://gitlab.gnome.org/GNOME/mutter/-/issues/3547.

(cherry picked from commit e621663)

Author: OnePatchGuy

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/CurrentDesktopInfo.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2026 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+import sun.awt.UNIXToolkit;
+
+import java.awt.Toolkit;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicReference;
+
+final class CurrentDesktopInfo {
+
+    private CurrentDesktopInfo() {}
+
+
+    public static boolean isGnome() {
+        Boolean result = isGnome.get();
+
+        if (result == null) {
+            synchronized (CurrentDesktopInfo.class) {
+                if (Toolkit.getDefaultToolkit() instanceof UNIXToolkit unixToolkit) {
+                    result = "gnome".equals(unixToolkit.getDesktop());
+                } else {
+                    result = false;
+                }
+
+                isGnome.set(result);
+            }
+
+            return result;
+        }
+
+        return result;
+    }
+    // {@code null} if not initialized yet
+    private static final AtomicReference<Boolean> isGnome = new AtomicReference<>(null);
+
+    /** negative if couldn't obtain or the desktop is not GNOME */
+    public static int getGnomeShellMajorVersion() {
+        Integer result = gnomeVersion.get();
+
+        if (result == null) {
+            synchronized (CurrentDesktopInfo.class) {
+                if (!isGnome()) {
+                    result = -1;
+                } else if (Toolkit.getDefaultToolkit() instanceof UNIXToolkit unixToolkit) {
+                    try {
+                        @SuppressWarnings("removal")
+                        final Integer version = AccessController.doPrivileged(
+                            (PrivilegedAction<Integer>)unixToolkit::getGnomeShellMajorVersion
+                        );
+
+                        result = Objects.requireNonNullElse(version, -1);
+                    } catch (Exception ignored) {
+                        result = -1;
+                    }
+                } else {
+                    result = -1;
+                }
+
+                gnomeVersion.set(result);
+            }
+
+            return result;
+        }
+
+        return result;
+    }
+    // {@code null} if not initialized yet, negative if couldn't obtain or the desktop is not GNOME
+    private static final AtomicReference<Integer> gnomeVersion = new AtomicReference<>(null);
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/IncomingChanges.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2025 JetBrains s.r.o.
+ * Copyright 2025-2026 JetBrains s.r.o.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,6 +25,7 @@
 
 package sun.awt.wl.im.text_input_unstable_v3;
 
+import java.nio.charset.CharacterCodingException;
 import java.util.Arrays;
 import java.util.Objects;
 
@@ -36,6 +37,25 @@
  */
 final class IncomingChanges
 {
+    public static class ConversionException extends java.io.IOException {
+        @java.io.Serial
+        private static final long serialVersionUID = 7010594789107134519L;
+
+        public ConversionException(String message) {
+            super(message);
+        }
+        public ConversionException(Throwable cause) {
+            super(cause);
+        }
+        public ConversionException(String message, Throwable cause) {
+            super(message, cause);
+        }
+        public ConversionException(Throwable cause, String format, Object... args) {
+            super(String.format(format, args), cause);
+        }
+    }
+
+
     public IncomingChanges updatePreeditString(byte[] newPreeditStringUtf8, int newPreeditStringCursorBeginUtf8Byte, int newPreeditStringCursorEndUtf8Byte) {
         this.doUpdatePreeditString = true;
         this.newPreeditStringUtf8 = newPreeditStringUtf8;
@@ -50,18 +70,30 @@ public IncomingChanges updatePreeditString(byte[] newPreeditStringUtf8, int newP
      * @return {@code null} if there are no changes in the preedit string
      *                      (i.e. {@link #updatePreeditString(byte[], int, int)} hasn't been called);
      *         an instance of JavaPreeditString otherwise.
+     * @throws ConversionException if failed to convert the data provided in {@link #updatePreeditString(byte[], int, int)}
+     *                             to an instance of JavaPreeditString.
      * @see JavaPreeditString
      */
-    public JavaPreeditString getPreeditString() {
+    public JavaPreeditString getPreeditString() throws ConversionException {
         if (cachedResultPreeditString != null) {
             return cachedResultPreeditString;
         }
 
-        cachedResultPreeditString = doUpdatePreeditString
-            ? JavaPreeditString.fromWaylandPreeditString(newPreeditStringUtf8, newPreeditStringCursorBeginUtf8Byte, newPreeditStringCursorEndUtf8Byte)
-            : null;
+        try {
+            cachedResultPreeditString = doUpdatePreeditString
+                ? JavaPreeditString.fromWaylandPreeditString(newPreeditStringUtf8, newPreeditStringCursorBeginUtf8Byte, newPreeditStringCursorEndUtf8Byte)
+                : null;
 
-        return cachedResultPreeditString;
+            return cachedResultPreeditString;
+        } catch (CharacterCodingException err) {
+            throw new ConversionException(
+                err,
+                "Failed to convert zwp_text_input_v3::preedit_string(%s, %d, %d) to JavaPreeditString",
+                byteArrayToHexArrayString(newPreeditStringUtf8),
+                newPreeditStringCursorBeginUtf8Byte,
+                newPreeditStringCursorEndUtf8Byte
+            );
+        }
     }
 
 
@@ -77,18 +109,28 @@ public IncomingChanges updateCommitString(byte[] newCommitStringUtf8) {
      * @return {@code null} if there are no changes in the commit string
      *                     (i.e. {@link #updateCommitString(byte[])}  hasn't been called);
      *         an instance of JavaCommitString otherwise.
+     * @throws ConversionException if failed to convert the data provided in {@link #updateCommitString(byte[])}
+     *                             to an instance of JavaCommitString.
      * @see JavaCommitString
      */
-    public JavaCommitString getCommitString() {
+    public JavaCommitString getCommitString() throws ConversionException {
         if (cachedResultCommitString != null) {
             return cachedResultCommitString;
         }
 
-        cachedResultCommitString = doUpdateCommitString
-            ? JavaCommitString.fromWaylandCommitString(newCommitStringUtf8)
-            : null;
+        try {
+            cachedResultCommitString = doUpdateCommitString
+                    ? JavaCommitString.fromWaylandCommitString(newCommitStringUtf8)
+                    : null;
 
-        return cachedResultCommitString;
+            return cachedResultCommitString;
+        } catch (CharacterCodingException err) {
+            throw new ConversionException(
+                err,
+                "Failed to convert zwp_text_input_v3::commit_string(%s) to JavaCommitString",
+                byteArrayToHexArrayString(newCommitStringUtf8)
+            );
+        }
     }
 
 
@@ -128,4 +170,27 @@ public int hashCode() {
     private boolean doUpdateCommitString = false;
     private byte[] newCommitStringUtf8 = null;
     private JavaCommitString cachedResultCommitString = null;
+
+
+    private static String byteArrayToHexArrayString(byte[] arr) {
+        if (arr == null)
+            return "null";
+
+        final int iMax = Math.min(arr.length - 1, 15);
+        if (iMax == -1)
+            return "[]";
+
+        final StringBuilder b = new StringBuilder();
+        b.append('[');
+        for (int i = 0; ; ++i) {
+            b.append("0x").append(Integer.toHexString(Byte.toUnsignedInt(arr[i])));
+            if (i == iMax) {
+                if (iMax < arr.length - 1) {
+                    b.append(", ...");
+                }
+                return b.append(']').toString();
+            }
+            b.append(", ");
+        }
+    }
 }

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/JavaCommitString.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2025 JetBrains s.r.o.
+ * Copyright 2025-2026 JetBrains s.r.o.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,6 +25,13 @@
 
 package sun.awt.wl.im.text_input_unstable_v3;
 
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CoderResult;
+import java.nio.charset.CodingErrorAction;
+import java.nio.charset.StandardCharsets;
 import java.util.Objects;
 
 record JavaCommitString(String text) {
@@ -34,8 +41,39 @@ record JavaCommitString(String text) {
 
     public static final JavaCommitString EMPTY = new JavaCommitString("");
 
-    /** Never returns {@code null}. */
-    public static JavaCommitString fromWaylandCommitString(byte[] utf8Bytes) {
-        return new JavaCommitString(Utilities.utf8BytesToJavaString(utf8Bytes));
+    /**
+     * Converts a UTF-8 string received in a {@code zwp_text_input_v3::commit_string} event to its UTF-16 equivalent.
+     *
+     * @return an instance of {@code JavaCommitString}. Never returns {@code null}.
+     * @throws CharacterCodingException if {@code utf8Bytes} doesn't represent a valid UTF-8 string.
+     */
+    public static JavaCommitString fromWaylandCommitString(byte[] utf8Bytes) throws CharacterCodingException {
+        // The only Unicode code point that can contain zero byte(s) is U+000000.
+        // It hardly makes sense to have it at the end of preedit/commit strings, so let's trim it.
+        final int utf8BytesCorrectedLength = Utilities.getLengthOfUtf8BytesWithoutTrailingNULs(utf8Bytes);
+
+        if (utf8BytesCorrectedLength < 1) {
+            return JavaCommitString.EMPTY;
+        }
+
+        final CharsetDecoder utf8Decoder = StandardCharsets.UTF_8.newDecoder()
+                                                                 .onMalformedInput(CodingErrorAction.REPORT)
+                                                                 // there can't be unmappable characters for this
+                                                                 //   kind of conversion, so REPLACE is just in case
+                                                                 .onUnmappableCharacter(CodingErrorAction.REPLACE);
+        final CharBuffer decodingBuffer = CharBuffer.allocate(utf8BytesCorrectedLength + 1);
+        final ByteBuffer utf8BytesBuffer = ByteBuffer.wrap(utf8Bytes, 0, utf8BytesCorrectedLength);
+
+        CoderResult decodingResult = utf8Decoder.decode(utf8BytesBuffer, decodingBuffer, true);
+        if (decodingResult.isError() || decodingResult.isOverflow()) {
+            decodingResult.throwException();
+        }
+
+        decodingResult = utf8Decoder.flush(decodingBuffer);
+        if (decodingResult.isError() || decodingResult.isOverflow()) {
+            decodingResult.throwException();
+        }
+
+        return new JavaCommitString(decodingBuffer.flip().toString());
     }
 }