Split flush and writeBytes into separate branches

Fix two issues flagged by Copilot:
1. flush path was nested inside writeBytes branch and never executed for flush
2. Second CAS could fail when isReady()=false (same curState used twice)

New structure:
- flushAction: only set readyAndDrained=false if isReady()=false (original behavior)
- writeBytes: always set readyAndDrained=false (Tomcat fix)

Also renamed second test to match actual behavior:
writeBytes_isReadyBecomesFalse_isBuffered -> writeBytes_isReadyFalse_buffersUntilOnWritePossible

Fixed test to actually set isReady=false and verify second write is buffered.

Addressed Copilot comments on PR #12790

Author: mgustimz

servlet/src/main/java/io/grpc/servlet/AsyncServletOutputStreamWriter.java

@@ -222,24 +222,24 @@ private void runOrBuffer(ActionItem actionItem) throws IOException {
       if (actionItem == completeAction) {
         return;
       }
-      if (actionItem != flushAction) {
-        // This is a writeBytes action. Always set readyAndDrained to false even when
-        // isReady() returns true. Tomcat requires onWritePossible() to fire between
-        // writes, even if isReady() is still true.
-        boolean successful =
-            writeState.compareAndSet(curState, curState.withReadyAndDrained(false));
-        LockSupport.unpark(parkingThread);
-        checkState(successful, "Bug: curState is unexpectedly changed by another thread");
-        log.finest("direct write: cleared readyAndDrained, next writes buffered");
-        // For flush, only set to false if isReady() returns false.
-        // If isReady() is still true, keep readyAndDrained true so flush goes direct.
+      if (actionItem == flushAction) {
+        // flush path: only set readyAndDrained=false if isReady() returns false
+        // If isReady() is still true, keep readyAndDrained=true so flush goes direct
         if (!isReady.getAsBoolean()) {
           boolean successful =
               writeState.compareAndSet(curState, curState.withReadyAndDrained(false));
           LockSupport.unpark(parkingThread);
           checkState(successful, "Bug: curState is unexpectedly changed by another thread");
           log.finest("the servlet output stream becomes not ready");
         }
+      } else {
+        // writeBytes path: always set readyAndDrained=false even when isReady()
+        // returns true. Tomcat requires onWritePossible() to fire between writes.
+        boolean successful =
+            writeState.compareAndSet(curState, curState.withReadyAndDrained(false));
+        LockSupport.unpark(parkingThread);
+        checkState(successful, "Bug: curState is unexpectedly changed by another thread");
+        log.finest("direct write: cleared readyAndDrained, next writes buffered");
       }
     } else { // buffer to the writeChain
       writeChain.offer(actionItem);

servlet/src/test/java/io/grpc/servlet/AsyncServletOutputStreamWriterTest.java

@@ -82,11 +82,12 @@ public void writeBytes_alwaysReady_doesNotStall() throws IOException {
   }
 
   /**
-   * Test that writeBytes with isReady transitioning from true to false eventually
-   * drains via onWritePossible.
+   * Test that when isReady() returns false, writes are buffered and only drain
+   * when onWritePossible() is called. This models the container behavior where
+   * writes block until the container signals the stream is ready again.
    */
   @Test
-  public void writeBytes_isReadyBecomesFalse_triggersOnWritePossible() throws IOException {
+  public void writeBytes_isReadyFalse_buffersUntilOnWritePossible() throws IOException {
     AtomicBoolean isReady = new AtomicBoolean(true);
     List<String> actions = new ArrayList<>();
 
@@ -106,22 +107,29 @@ public void writeBytes_isReadyBecomesFalse_triggersOnWritePossible() throws IOEx
     AsyncServletOutputStreamWriter writer =
         new AsyncServletOutputStreamWriter(writeAction, flushAction, completeAction, isReadySupplier, new Log() {});
 
-    // Initial onWritePossible
+    // Initial onWritePossible to set readyAndDrained=true
     writer.onWritePossible();
 
     // First write - isReady is true, goes direct, readyAndDrained=false
     byte[] data1 = new byte[]{1};
     writer.writeBytes(data1, 1);
 
-    // Container calls onWritePossible after first write completes internally
-    // isReady is still true but readyAndDrained is false, so buffered writes drain
-    writer.onWritePossible();
+    // Simulate isReady becoming false (container buffer full)
+    isReady.set(false);
 
-    // Second write after isReady returns to true
-    isReady.set(true);
+    // Second write - should be buffered since isReady=false
     byte[] data2 = new byte[]{2};
     writer.writeBytes(data2, 1);
 
-    assertEquals("Two writes should complete", 2, actions.size());
+    // Only the first write should have executed
+    assertEquals("First write should complete, second buffered", 1, actions.size());
+
+    // Container calls onWritePossible when ready to accept more data
+    // isReady is still false, but onWritePossible will drain anyway
+    isReady.set(true);
+    writer.onWritePossible();
+
+    // Now both writes should have completed
+    assertEquals("Both writes should complete after onWritePossible", 2, actions.size());
   }
 }