[Android] Fix BundleDownloader Content-Type matching for Metro's "application/javascript; charset=UTF-8"

Regression introduced in the streaming refactor (e9e200a).

Metro actually serves the JS bundle chunk with
  Content-Type: application/javascript; charset=UTF-8
not the bare `application/javascript` my refactor was matching against.
With strict equality, `onChunkHeader` returned null (so the streaming
sink was never opened), the body was buffered into the in-memory
accumulator, and `onChunkComplete` hit the `else -> Unit` branch and
silently dropped it. Symptoms in dev on the RNTester emulator: heap
spiked to ~200 MB during the download, then dropped back, but the dev
loading view sat at "Bundling 99%" forever because callback.onSuccess()
was never fired.

Fix: parse Content-Type properly. New private helper `mediaType(...)`
strips the parameter portion (`; charset=...`) and lower-cases the
result, and the two routing predicates (`isJsBundleChunk` and
`isProgressChunk`) compare against the parsed media type. Also: the
else branch now logs a warning instead of silently dropping, so a
future Metro change that introduces yet another Content-Type variant
will be visible in logcat rather than stranding the user at 99%.

Updated `LargeMultipartSource` to emit the real Metro Content-Type
(`application/javascript; charset=UTF-8`) so the perf tests guard
against this exact regression class going forward. The perf tests pass
unchanged \u2014 the streaming path is still taken, output-size still equals
payloadBytes, and peak heap is still bounded.

Verified against a live Metro dev server: with the synthetic source
now matching production, `BundleDownloaderPerfTest` would have caught
this bug. `MultipartStreamReaderTest` (the 4 existing correctness
cases) is unaffected and still green.

Author: AndreiCalazans

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/devsupport/BundleDownloader.kt

@@ -243,7 +243,7 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
 
     @Throws(IOException::class)
     override fun onChunkHeader(headers: Map<String, String>): BufferedSink? {
-      if (headers["Content-Type"] != "application/javascript") return null
+      if (!isJsBundleChunk(headers)) return null
       val effectiveStatus = effectiveStatus(headers)
       if (effectiveStatus != 200) return null
       // Stream the JS bundle straight to disk — never materialize in heap.
@@ -265,8 +265,8 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
         finalizeStreamedBundle(headers)
         return
       }
-      when (headers["Content-Type"]) {
-        "application/javascript" -> {
+      when {
+        isJsBundleChunk(headers) -> {
           // Bundle returned with an error status — it was buffered so we can surface a useful
           // diagnostic to the developer.
           val buffered = body ?: Buffer()
@@ -280,8 +280,12 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
               callback,
           )
         }
-        "application/json" -> dispatchProgressJson(body)
-        else -> Unit // Unknown chunk type; ignore as before.
+        isProgressChunk(headers) -> dispatchProgressJson(body)
+        else -> {
+          // Unknown chunk type. Log so a future Metro change is visible in logcat instead of
+          // silently stranding the dev loading view at 99%.
+          FLog.w(TAG, "Ignoring multipart chunk with unrecognized Content-Type: ${headers["Content-Type"]}")
+        }
       }
     }
 
@@ -339,6 +343,20 @@ public class BundleDownloader public constructor(private val client: OkHttpClien
 
     private fun effectiveStatus(headers: Map<String, String>): Int =
         headers["X-Http-Status"]?.toIntOrNull() ?: outerStatus
+
+    /**
+     * Extract the media type (the part before `;`) from a Content-Type header, lower-cased.
+     * Metro sends e.g. `application/javascript; charset=UTF-8`, so a bare-string equality
+     * check would miss the bundle chunk and leave the dev loading view stranded.
+     */
+    private fun mediaType(headers: Map<String, String>): String? =
+        headers["Content-Type"]?.substringBefore(';')?.trim()?.lowercase()
+
+    private fun isJsBundleChunk(headers: Map<String, String>): Boolean =
+        mediaType(headers) == "application/javascript"
+
+    private fun isProgressChunk(headers: Map<String, String>): Boolean =
+        mediaType(headers) == "application/json"
   }
 
   @Throws(IOException::class)

packages/react-native/ReactAndroid/src/test/java/com/facebook/react/devsupport/LargeMultipartSource.kt

@@ -42,9 +42,11 @@ internal class LargeMultipartSource(
   // NB: the reader's delimiter is "\r\n--<boundary>\r\n", so the preamble must end with CRLF.
   // A bare CRLF is the minimal valid preamble.
   private val preamble: ByteArray = "\r\n".toByteArray(Charsets.UTF_8)
+  // Note: matches what Metro actually sends. The `charset=UTF-8` parameter exists to catch
+  // any future regression to bare-string Content-Type matching in BundleDownloader.
   private val headers: ByteArray =
       ("--$boundary\r\n" +
-              "Content-Type: application/javascript\r\n" +
+              "Content-Type: application/javascript; charset=UTF-8\r\n" +
               "Content-Length: $payloadBytes\r\n" +
               "\r\n")
           .toByteArray(Charsets.UTF_8)

packages/react-native/ReactAndroid/src/test/java/com/facebook/react/devsupport/MultipartStreamReaderPerfTest.kt

@@ -102,7 +102,8 @@ class MultipartStreamReaderPerfTest {
     // and surfaced via onChunkComplete.
     assertThat(success).isTrue
     assertThat(discardingSink.bytesWritten).isEqualTo(payloadBytes)
-    assertThat(receivedHeaders["Content-Type"]).isEqualTo("application/javascript")
+    assertThat(receivedHeaders["Content-Type"])
+        .isEqualTo("application/javascript; charset=UTF-8")
     assertThat(bufferDeliveredViaComplete)
         .`as`("Body must be streamed to the sink, not delivered as a Buffer")
         .isFalse