native rebinding now preserves overwritten translated JS method functions

Author: shai-almog

Ports/JavaScriptPort/STATUS.md

@@ -19,6 +19,8 @@ Current State
 - Note: a short-lived `forceShow()` experiment in `BaseTest.registerReadyCallback` was reverted because it caused re-entrant callback loops and prevented `CN1SS:SUITE:FINISHED`.
 - New patch (not yet CI-validated in this document revision): host screenshot capture now tracks the real draw target canvas and includes off-DOM canvases reachable via host refs.
 - New patch (not yet CI-validated in this document revision): screenshot candidate selection now prioritizes near-screen-sized canvases to prevent tiny offscreen buffers from being selected (fixes unexpected `120x80`/`4x4` outputs).
+- New patch (not yet CI-validated in this document revision): native rebinding now preserves overwritten translated JS method functions in `jvm.translatedMethods` for targeted fallback/original resolution.
+- New patch (not yet CI-validated in this document revision): canvas visual scoring now samples multiple regions (not only center), to better detect non-white drawn content.
 
 What Was Fixed In This Pass
 ---------------------------
@@ -125,6 +127,26 @@ What Was Fixed In This Pass
    - Motivation:
      - Latest artifacts showed mixed dimensions (`120x80`, `4x4`) and colored tiny captures, indicating offscreen utility buffers were being selected.
 
+11. Added translated-method preservation during native rebinding.
+   - Files:
+     - `vm/ByteCodeTranslator/src/javascript/parparvm_runtime.js`
+     - `Ports/JavaScriptPort/src/main/webapp/port.js`
+   - Changes:
+     - Runtime now records pre-override translated functions in `jvm.translatedMethods` when installing/reinstalling natives.
+     - `Cn1ssDeviceRunnerHelper.emitCurrentFormScreenshot...` fallback resolution now checks `jvm.translatedMethods` before globals/class tables.
+     - CI fallback wrappers are tagged (`__cn1CiFallbackSymbol`) so resolution can skip recursive self-selection.
+   - Motivation:
+     - `originalMissing=1` persisted even though translated helper symbols exist in `translated_app.js`; rebinding order was losing discoverability of original translated handlers.
+
+12. Improved screenshot canvas scoring robustness.
+   - File:
+     - `vm/ByteCodeTranslator/src/javascript/browser_bridge.js`
+   - Changes:
+     - Replaced single-center 48x48 sample with multi-region sampling (center, corners, and edge midpoints).
+     - Score still prefers non-white/opaque content, but now reflects content distribution across the frame.
+   - Motivation:
+     - White-frame capture can occur when center-only sampling misses rendered content (e.g., content concentrated away from center).
+
 Known Failing Symptoms (Latest CI Logs/Artifacts)
 -------------------------------------------------
 
@@ -136,6 +158,12 @@ Known Failing Symptoms (Latest CI Logs/Artifacts)
     - Seen in `ValidatorLightweightPickerScreenshotTest`, `InPlaceEditViewTest`, `StreamApiTest`, `TimeApiTest`.
 - Timeout-only tests still timeout by design/behavior (`MediaPlayback...`, `BytecodeTranslatorRegression...`, selected API tests).
 - Screenshot pixels are still wrong in CI (host-canvas fallback path remains dominant in logs).
+- Local note from current workspace revalidation:
+  - Fresh locally built bundle (`/tmp/hellocodenameone-javascript-port-local.zip`) currently emits only `bootstrap_placeholder` as a named stream.
+  - Browser diagnostics in that run show repeated:
+    - `PARPAR:DIAG:FALLBACK:cn1ssEmitCurrentFormScreenshotDom:originalMissing=1`
+    - `PARPAR:DIAG:FALLBACK:cn1ssEmitCurrentFormScreenshotDom:noCanvas=1:test=...`
+  - This local symptom differs from the latest CI artifacts (which still emit 32 screenshots, mostly white), so CI confirmation is required before accepting/rejecting the current translated-method resolution patch.
 
 Other CI Signal
 ---------------
@@ -151,11 +179,12 @@ Priority Next Steps
    - Confirm `settleChanged`, `canvasSig`, and `canvasSource` diagnostics vary across tests.
 2. Validate size normalization after large-canvas gating:
    - Expect screenshot dimensions to remain consistent at app target size (no `120x80`/`4x4` non-bootstrap outputs).
-3. If white-frame reuse persists, capture and compare per-test `settleSig`/`canvasSig`/`canvasSource` to identify whether paint is not happening or capture target is still wrong.
-3. Fix per-test null receiver/init path (`__classDef` null) at first failing stack, not via broad fallbacks.
-4. Fix missing `Button.initLaf(UIManager)` symbol resolution in worker runtime path.
-5. Fix worker-mode orientation lock path so DOM access is host-bridge mediated (no direct `document` access in worker).
-6. Confirm VM completeness stability in CI with parser/runtime patches (`expected 7` consistently).
+3. Validate `originalResolved=translated:...` vs `originalMissing=1` in CI browser log after translated-method preservation patch.
+4. If white-frame reuse persists, capture and compare per-test `settleSig`/`canvasSig`/`canvasSource` to identify whether paint is not happening or capture target is still wrong.
+5. Fix per-test null receiver/init path (`__classDef` null) at first failing stack, not via broad fallbacks.
+6. Fix missing `Button.initLaf(UIManager)` symbol resolution in worker runtime path.
+7. Fix worker-mode orientation lock path so DOM access is host-bridge mediated (no direct `document` access in worker).
+8. Confirm VM completeness stability in CI with parser/runtime patches (`expected 7` consistently).
 
 Files Touched In This Pass
 --------------------------

Ports/JavaScriptPort/src/main/webapp/port.js

@@ -188,24 +188,28 @@ function emitCiFallbackMarker(symbol, markerType) {
 }
 function bindCiFallback(symbol, names, fn) {
   emitCiFallbackMarker(symbol, "ENABLED");
-  bindNative(names, function*() {
+  const wrappedFallback = function*() {
     emitCiFallbackMarker(symbol, "HIT");
     return yield* fn.apply(this, arguments);
-  });
+  };
+  wrappedFallback.__cn1CiFallbackSymbol = symbol;
+  bindNative(names, wrappedFallback);
 }
 function bindCiFallbackWithMethodId(symbol, names, fn) {
   emitCiFallbackMarker(symbol, "ENABLED");
   for (let i = 0; i < names.length; i++) {
     const methodId = names[i];
-    bindNative([methodId], function*() {
+    const wrappedFallback = function*() {
       emitCiFallbackMarker(symbol, "HIT");
       const args = new Array(arguments.length + 1);
       args[0] = methodId;
       for (let j = 0; j < arguments.length; j++) {
         args[j + 1] = arguments[j];
       }
       return yield* fn.apply(this, args);
-    });
+    };
+    wrappedFallback.__cn1CiFallbackSymbol = symbol;
+    bindNative([methodId], wrappedFallback);
   }
 }
 function aliasGlobalToImpl(symbol) {
@@ -3111,23 +3115,60 @@ function emitCn1ssChunks(base64, testName, channelName) {
 }
 
 const cn1ssEmitCurrentFormScreenshotMethodId = "cn1_com_codenameone_examples_hellocodenameone_tests_Cn1ssDeviceRunnerHelper_emitCurrentFormScreenshot_java_lang_String_java_lang_Runnable";
-const cn1ssEmitCurrentFormScreenshotOriginal =
-  (typeof global[cn1ssEmitCurrentFormScreenshotMethodId] === "function")
-    ? global[cn1ssEmitCurrentFormScreenshotMethodId]
-    : ((typeof global[cn1ssEmitCurrentFormScreenshotMethodId + "__impl"] === "function")
-      ? global[cn1ssEmitCurrentFormScreenshotMethodId + "__impl"]
-      : null);
+const cn1ssHelperClassName = "com_codenameone_examples_hellocodenameone_tests_Cn1ssDeviceRunnerHelper";
+
+function isFallbackFunctionForSymbol(fn, symbol) {
+  return !!(fn && fn.__cn1CiFallbackSymbol === symbol);
+}
+
+function resolveTranslatedMethodCandidate(methodIds, ownerClassName, fallbackSymbol) {
+  const translatedMethods = jvm && jvm.translatedMethods ? jvm.translatedMethods : null;
+  if (translatedMethods) {
+    for (let i = 0; i < methodIds.length; i++) {
+      const methodId = methodIds[i];
+      const candidate = translatedMethods[methodId];
+      if (typeof candidate === "function" && !isFallbackFunctionForSymbol(candidate, fallbackSymbol)) {
+        return { fn: candidate, source: "translated:" + methodId };
+      }
+    }
+  }
+  for (let i = 0; i < methodIds.length; i++) {
+    const methodId = methodIds[i];
+    const candidate = global[methodId];
+    if (typeof candidate === "function" && !isFallbackFunctionForSymbol(candidate, fallbackSymbol)) {
+      return { fn: candidate, source: "global:" + methodId };
+    }
+  }
+  const ownerClass = jvm && jvm.classes ? jvm.classes[ownerClassName] : null;
+  const methods = ownerClass && ownerClass.methods ? ownerClass.methods : null;
+  if (methods) {
+    for (let i = 0; i < methodIds.length; i++) {
+      const methodId = methodIds[i];
+      const candidate = methods[methodId];
+      if (typeof candidate === "function" && !isFallbackFunctionForSymbol(candidate, fallbackSymbol)) {
+        return { fn: candidate, source: "class:" + ownerClassName + ":" + methodId };
+      }
+    }
+  }
+  return null;
+}
 
 bindCiFallback("Cn1ssDeviceRunnerHelper.emitCurrentFormScreenshotDom", [
   cn1ssEmitCurrentFormScreenshotMethodId,
   cn1ssEmitCurrentFormScreenshotMethodId + "__impl"
 ], function*(testName, completion) {
+  const fallbackSymbol = "Cn1ssDeviceRunnerHelper.emitCurrentFormScreenshotDom";
   const test = toCn1StringValue(testName);
   const normalizedTest = resolveCn1ssTestName(test);
   let shouldUseDomFallback = true;
-  if (typeof cn1ssEmitCurrentFormScreenshotOriginal === "function") {
+  const originalResolved = resolveTranslatedMethodCandidate([
+    cn1ssEmitCurrentFormScreenshotMethodId,
+    cn1ssEmitCurrentFormScreenshotMethodId + "__impl"
+  ], cn1ssHelperClassName, fallbackSymbol);
+  if (originalResolved && typeof originalResolved.fn === "function") {
     try {
-      yield* cn1ssEmitCurrentFormScreenshotOriginal(testName, completion);
+      emitDiagLine("PARPAR:DIAG:FALLBACK:cn1ssEmitCurrentFormScreenshotDom:originalResolved=" + originalResolved.source);
+      yield* originalResolved.fn(testName, completion);
       return null;
     } catch (originalErr) {
       emitDiagLine("PARPAR:DIAG:FALLBACK:cn1ssEmitCurrentFormScreenshotDom:originalInvokeErr="

vm/ByteCodeTranslator/src/javascript/browser_bridge.js

@@ -434,35 +434,62 @@
     }
     var sampleW = Math.min(48, w);
     var sampleH = Math.min(48, h);
-    var startX = ((w - sampleW) / 2) | 0;
-    var startY = ((h - sampleH) / 2) | 0;
-    var img;
-    try {
-      img = ctx.getImageData(startX, startY, sampleW, sampleH);
-    } catch (_err) {
-      return null;
-    }
-    if (!img || !img.data || !img.data.length) {
-      return null;
-    }
-    var data = img.data;
+    var regions = [
+      [0.5, 0.5],
+      [0.2, 0.2], [0.8, 0.2], [0.2, 0.8], [0.8, 0.8],
+      [0.5, 0.2], [0.5, 0.8], [0.2, 0.5], [0.8, 0.5]
+    ];
     var opaqueCount = 0;
     var nonWhiteCount = 0;
-    for (var i = 0; i < data.length; i += 4) {
-      var r = data[i] | 0;
-      var g = data[i + 1] | 0;
-      var b = data[i + 2] | 0;
-      var a = data[i + 3] | 0;
-      if (a > 12) {
-        opaqueCount++;
-        if (!(r >= 248 && g >= 248 && b >= 248)) {
-          nonWhiteCount++;
+    var signature = 'none';
+    var sigHash = 2166136261 >>> 0;
+    var sampled = 0;
+    for (var ri = 0; ri < regions.length; ri++) {
+      var rx = regions[ri][0];
+      var ry = regions[ri][1];
+      var startX = Math.max(0, Math.min(w - sampleW, (((w - sampleW) * rx) | 0)));
+      var startY = Math.max(0, Math.min(h - sampleH, (((h - sampleH) * ry) | 0)));
+      var img;
+      try {
+        img = ctx.getImageData(startX, startY, sampleW, sampleH);
+      } catch (_err) {
+        continue;
+      }
+      if (!img || !img.data || !img.data.length) {
+        continue;
+      }
+      sampled++;
+      var data = img.data;
+      for (var i = 0; i < data.length; i += 4) {
+        var r = data[i] | 0;
+        var g = data[i + 1] | 0;
+        var b = data[i + 2] | 0;
+        var a = data[i + 3] | 0;
+        if (a > 12) {
+          opaqueCount++;
+          if (!(r >= 248 && g >= 248 && b >= 248)) {
+            nonWhiteCount++;
+          }
+        }
+        if ((i & 31) === 0) {
+          sigHash ^= r;
+          sigHash = Math.imul(sigHash, 16777619);
+          sigHash ^= g;
+          sigHash = Math.imul(sigHash, 16777619);
+          sigHash ^= b;
+          sigHash = Math.imul(sigHash, 16777619);
+          sigHash ^= a;
+          sigHash = Math.imul(sigHash, 16777619);
         }
       }
     }
+    if (sampled === 0) {
+      return null;
+    }
+    signature = String((sigHash >>> 0).toString(16));
     return {
       score: (nonWhiteCount * 4) + opaqueCount,
-      signature: shortSignatureFromImageData(img)
+      signature: signature
     };
   }
 

vm/ByteCodeTranslator/src/javascript/parparvm_runtime.js

@@ -1797,7 +1797,19 @@ function bindNative(names, fn) {
       cls.methods[name] = fn;
     }
   }
+  function rememberTranslatedMethod(name, existingFn) {
+    if (typeof existingFn !== "function" || existingFn === fn) {
+      return;
+    }
+    if (!jvm.translatedMethods) {
+      jvm.translatedMethods = Object.create(null);
+    }
+    if (typeof jvm.translatedMethods[name] !== "function") {
+      jvm.translatedMethods[name] = existingFn;
+    }
+  }
   function registerNative(name) {
+    rememberTranslatedMethod(name, global[name]);
     jvm.nativeMethods[name] = fn;
     global[name] = fn;
     jvm[name] = fn;
@@ -1831,16 +1843,32 @@ function installCompatibilityClasses() {
   }
 }
 function installNativeBindings() {
+  if (!jvm.translatedMethods) {
+    jvm.translatedMethods = Object.create(null);
+  }
   const names = Object.keys(jvm.nativeMethods || {});
   for (let i = 0; i < names.length; i++) {
     const name = names[i];
     const nativeFn = jvm.nativeMethods[name];
     if (typeof nativeFn !== "function") {
       continue;
     }
+    const existingGlobal = global[name];
+    if (typeof existingGlobal === "function" && existingGlobal !== nativeFn) {
+      if (typeof jvm.translatedMethods[name] !== "function") {
+        jvm.translatedMethods[name] = existingGlobal;
+      }
+    }
     global[name] = nativeFn;
     jvm[name] = nativeFn;
     if (!name.endsWith("__impl")) {
+      const implName = name + "__impl";
+      const existingImpl = global[implName];
+      if (typeof existingImpl === "function" && existingImpl !== nativeFn) {
+        if (typeof jvm.translatedMethods[implName] !== "function") {
+          jvm.translatedMethods[implName] = existingImpl;
+        }
+      }
       global[name + "__impl"] = nativeFn;
       jvm[name + "__impl"] = nativeFn;
     }