Coalesce small buffers in net::BidirectionalStream

components/cronet/android/test/javatests/src/org/chromium/net/BidirectionalStreamTest.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.net;
 
 import android.os.ConditionVariable;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import org.chromium.base.test.util.DisabledTest;
@@ skipping 218 matching lines @@
         assertEquals("Test String1234567890woot!", callback.mResponseAsString);
         assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
         assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
         assertEquals(
                 "zebra", callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
+    public void testSimplePostWithFlush() throws Exception {
+        String url = Http2TestServer.getEchoStreamUrl();
+        TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
+        callback.addWriteData("Test String".getBytes(), false);
+        callback.addWriteData("1234567890".getBytes(), false);
+        callback.addWriteData("woot!".getBytes(), true);
+        BidirectionalStream stream = new BidirectionalStream
+                                             .Builder(url, callback, callback.getExecutor(),
+                                                     mTestFramework.mCronetEngine)
+                                             .disableAutoFlush(true)
+                                             .addHeader("foo", "bar")
+                                             .addHeader("empty", "")
+                                             .addHeader("Content-Type", "zebra")
+                                             .build();
+        stream.start();
+        callback.blockForDone();
+        assertTrue(stream.isDone());
+
+        // Flush after stream is completed is no-op. It shouldn't call into the destroyed adapter.
+        stream.flush();
+
+        assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
+        assertEquals("Test String1234567890woot!", callback.mResponseAsString);
+        assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
+        assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
+        assertEquals(
+                "zebra", callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    @OnlyRunNativeCronet
+    public void testSimplePostWithFlushTwice() throws Exception {
+        String url = Http2TestServer.getEchoStreamUrl();
+        TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
+        callback.addWriteData("Test String".getBytes(), false);
+        callback.addWriteData("1234567890".getBytes(), false);
+        callback.addWriteData("woot!".getBytes(), true);
+        callback.addWriteData("Test String".getBytes(), false);
+        callback.addWriteData("1234567890".getBytes(), false);
+        callback.addWriteData("woot!".getBytes(), true);
+        BidirectionalStream stream = new BidirectionalStream
+                                             .Builder(url, callback, callback.getExecutor(),
+                                                     mTestFramework.mCronetEngine)
+                                             .disableAutoFlush(true)
+                                             .addHeader("foo", "bar")
+                                             .addHeader("empty", "")
+                                             .addHeader("Content-Type", "zebra")
+                                             .build();
+        stream.start();
+        callback.blockForDone();
+        assertTrue(stream.isDone());
+        assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
+        assertEquals(
+                "Test String1234567890woot!Test String1234567890woot!", callback.mResponseAsString);
+        assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
+        assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
+        assertEquals(
+                "zebra", callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    @OnlyRunNativeCronet
+    // Tests that it is legal to call read() in onStreamReady().
+    public void testReadDuringOnStreamReady() throws Exception {
+        String url = Http2TestServer.getEchoStreamUrl();
+        TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback() {
+            @Override
+            public void onStreamReady(BidirectionalStream stream) {
+                super.onStreamReady(stream);
+                startNextRead(stream);
+            }
+            @Override
+            public void onResponseHeadersReceived(
+                    BidirectionalStream stream, UrlResponseInfo info) {
+                // Do nothing. Skip readng.
+            }
+        };
+        callback.addWriteData("Test String".getBytes());
+        callback.addWriteData("1234567890".getBytes());
+        callback.addWriteData("woot!".getBytes());
+        BidirectionalStream stream = new BidirectionalStream
+                                             .Builder(url, callback, callback.getExecutor(),
+                                                     mTestFramework.mCronetEngine)
+                                             .addHeader("foo", "bar")
+                                             .addHeader("empty", "")
+                                             .addHeader("Content-Type", "zebra")
+                                             .build();
+        stream.start();
+        callback.blockForDone();
+        assertTrue(stream.isDone());
+        assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
+        assertEquals("Test String1234567890woot!", callback.mResponseAsString);
+        assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
+        assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
+        assertEquals(
+                "zebra", callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    @OnlyRunNativeCronet
+    // Tests that it is legal to call flush() when previous nativeWritevData has
+    // yet to complete.
+    public void testSimplePostWithFlushBeforePreviousWriteCompleted() throws Exception {
+        String url = Http2TestServer.getEchoStreamUrl();
+        TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback() {
+            @Override
+            public void onStreamReady(BidirectionalStream stream) {
+                super.onStreamReady(stream);
+                // Write a second time before the previous nativeWritevData has completed.
+                startNextWrite(stream);
+                assertEquals(0, numPendingWrites());
+            }
+        };
+        callback.addWriteData("Test String".getBytes(), false);
+        callback.addWriteData("1234567890".getBytes(), false);
+        callback.addWriteData("woot!".getBytes(), true);
+        callback.addWriteData("Test String".getBytes(), false);
+        callback.addWriteData("1234567890".getBytes(), false);
+        callback.addWriteData("woot!".getBytes(), true);
+        BidirectionalStream stream = new BidirectionalStream
+                                             .Builder(url, callback, callback.getExecutor(),
+                                                     mTestFramework.mCronetEngine)
+                                             .disableAutoFlush(true)
+                                             .addHeader("foo", "bar")
+                                             .addHeader("empty", "")
+                                             .addHeader("Content-Type", "zebra")
+                                             .build();
+        stream.start();
+        callback.blockForDone();
+        assertTrue(stream.isDone());
+        assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
+        assertEquals(
+                "Test String1234567890woot!Test String1234567890woot!", callback.mResponseAsString);
+        assertEquals("bar", callback.mResponseInfo.getAllHeaders().get("echo-foo").get(0));
+        assertEquals("", callback.mResponseInfo.getAllHeaders().get("echo-empty").get(0));
+        assertEquals(
+                "zebra", callback.mResponseInfo.getAllHeaders().get("echo-content-type").get(0));
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    @OnlyRunNativeCronet
     public void testSimplePut() throws Exception {
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.addWriteData("Put This Data!".getBytes());
         String methodName = "PUT";
         BidirectionalStream.Builder builder =
                 new BidirectionalStream.Builder(Http2TestServer.getServerUrl(), callback,
                         callback.getExecutor(), mTestFramework.mCronetEngine);
         builder.setHttpMethod(methodName);
         builder.build().start();
         callback.blockForDone();
@@ skipping 227 matching lines @@
         assertEquals("", callback.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testDoubleWrite() throws Exception {
         String url = Http2TestServer.getEchoStreamUrl();
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback() {
             @Override
-            public void onRequestHeadersSent(BidirectionalStream stream) {
+            public void onStreamReady(BidirectionalStream stream) {
+                // super class will call Write() once.
+                super.onStreamReady(stream);
+                // Call Write() again.
                 startNextWrite(stream);
-                try {
-                    // Second write from callback invoked on single-threaded executor throws
-                    // an exception because first write is still pending until its completion
-                    // is handled on executor.
-                    ByteBuffer writeBuffer = ByteBuffer.allocateDirect(5);
-                    writeBuffer.put("abc".getBytes());
-                    writeBuffer.flip();
-                    stream.write(writeBuffer, false);
-                    fail("Exception is not thrown.");
-                } catch (Exception e) {
-                    assertEquals("Unexpected write attempt.", e.getMessage());
-                }
+                // Make sure there is no pending write.
+                assertEquals(0, numPendingWrites());
             }
         };
         callback.addWriteData("1".getBytes());
         callback.addWriteData("2".getBytes());
         // Create stream.
         BidirectionalStream stream = new BidirectionalStream
                                              .Builder(url, callback, callback.getExecutor(),
                                                      mTestFramework.mCronetEngine)
                                              .build();
         stream.start();
@@ skipping 87 matching lines @@
             callback.addWriteData(writeData.getBytes());
             stringData.append(writeData);
         }
         // Create stream.
         BidirectionalStream stream = new BidirectionalStream
                                              .Builder(url, callback, callback.getExecutor(),
                                                      mTestFramework.mCronetEngine)
                                              .build();
         stream.start();
         // Write first.
-        callback.waitForNextWriteStep();
+        callback.waitForNextWriteStep(); // onStreamReady
         for (String expected : testData) {
             // Write next chunk of test data.
             callback.startNextWrite(stream);
-            callback.waitForNextWriteStep();
+            callback.waitForNextWriteStep(); // onWriteCompleted
         }
 
         // Wait for read step, but don't read yet.
-        callback.waitForNextReadStep();
+        callback.waitForNextReadStep(); // onResponseHeadersReceived
         assertEquals("", callback.mResponseAsString);
         // Read back.
         callback.startNextRead(stream);
-        callback.waitForNextReadStep();
+        callback.waitForNextReadStep(); // onReadCompleted
         // Verify that some part of proper response is read.
         assertTrue(callback.mResponseAsString.startsWith(testData[0]));
         assertTrue(stringData.toString().startsWith(callback.mResponseAsString));
         // Read the rest of the response.
         callback.setAutoAdvance(true);
         callback.startNextRead(stream);
         callback.blockForDone();
         assertTrue(stream.isDone());
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals(stringData.toString(), callback.mResponseAsString);
@@ skipping 106 matching lines @@
 
         // Make sure position and limit were updated correctly.
         assertEquals(4, readBuffer.position());
         assertEquals(5, readBuffer.limit());
 
         assertEquals(ResponseStep.ON_READ_COMPLETED, callback.mResponseStep);
 
         // One more read attempt. The request should complete.
         readBuffer.position(1);
         readBuffer.limit(5);
+        callback.setAutoAdvance(true);
         callback.startNextRead(stream, readBuffer);
-        callback.waitForNextReadStep();
+        callback.blockForDone();
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         assertEquals("GET", callback.mResponseAsString);
         checkResponseInfo(callback.mResponseInfo, Http2TestServer.getEchoMethodUrl(), 200, "");
 
         // Check that buffer contents were not modified.
         assertEquals("FORTE", bufferContentsToString(readBuffer, 0, 5));
 
         // Position should not have been modified, since nothing was read.
         assertEquals(1, readBuffer.position());
@@ skipping 58 matching lines @@
         TestBidirectionalStreamCallback callback = new TestBidirectionalStreamCallback();
         callback.setFailure(failureType, failureStep);
         BidirectionalStream.Builder builder =
                 new BidirectionalStream.Builder(Http2TestServer.getEchoMethodUrl(), callback,
                         callback.getExecutor(), mTestFramework.mCronetEngine);
         BidirectionalStream stream = builder.setHttpMethod("GET").build();
         stream.start();
         callback.blockForDone();
         // assertEquals(callback.mResponseStep, failureStep);
         assertTrue(stream.isDone());
-        // Cancellation when request headers are sent does not guarantee that
+        // Cancellation when stream is ready does not guarantee that
         // mResponseInfo is null because there might be a
         // onResponseHeadersReceived already queued in the executor.
         // See crbug.com/594432.
-        if (failureStep != ResponseStep.ON_REQUEST_HEADERS_SENT) {
+        if (failureStep != ResponseStep.ON_STREAM_READY) {
             assertNotNull(callback.mResponseInfo);
         }
         assertEquals(expectError, callback.mError != null);
         assertEquals(expectError, callback.mOnErrorCalled);
         assertEquals(failureType == FailureType.CANCEL_SYNC
                         || failureType == FailureType.CANCEL_ASYNC
                         || failureType == FailureType.CANCEL_ASYNC_WITHOUT_PAUSE,
                 callback.mOnCanceledCalled);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     public void testFailures() throws Exception {
-        throwOrCancel(FailureType.CANCEL_SYNC, ResponseStep.ON_REQUEST_HEADERS_SENT, false);
-        throwOrCancel(FailureType.CANCEL_ASYNC, ResponseStep.ON_REQUEST_HEADERS_SENT, false);
-        throwOrCancel(FailureType.CANCEL_ASYNC_WITHOUT_PAUSE, ResponseStep.ON_REQUEST_HEADERS_SENT,
-                false);
-        throwOrCancel(FailureType.THROW_SYNC, ResponseStep.ON_REQUEST_HEADERS_SENT, true);
+        throwOrCancel(FailureType.CANCEL_SYNC, ResponseStep.ON_STREAM_READY, false);
+        throwOrCancel(FailureType.CANCEL_ASYNC, ResponseStep.ON_STREAM_READY, false);
+        throwOrCancel(FailureType.CANCEL_ASYNC_WITHOUT_PAUSE, ResponseStep.ON_STREAM_READY, false);
+        throwOrCancel(FailureType.THROW_SYNC, ResponseStep.ON_STREAM_READY, true);
 
         throwOrCancel(FailureType.CANCEL_SYNC, ResponseStep.ON_RESPONSE_STARTED, false);
         throwOrCancel(FailureType.CANCEL_ASYNC, ResponseStep.ON_RESPONSE_STARTED, false);
         throwOrCancel(
                 FailureType.CANCEL_ASYNC_WITHOUT_PAUSE, ResponseStep.ON_RESPONSE_STARTED, false);
         throwOrCancel(FailureType.THROW_SYNC, ResponseStep.ON_RESPONSE_STARTED, true);
 
         throwOrCancel(FailureType.CANCEL_SYNC, ResponseStep.ON_READ_COMPLETED, false);
         throwOrCancel(FailureType.CANCEL_ASYNC, ResponseStep.ON_READ_COMPLETED, false);
         throwOrCancel(
@@ skipping 190 matching lines @@
     private static String bufferContentsToString(ByteBuffer byteBuffer, int start, int end) {
         // Use a duplicate to avoid modifying byteBuffer.
         ByteBuffer duplicate = byteBuffer.duplicate();
         duplicate.position(start);
         duplicate.limit(end);
         byte[] contents = new byte[duplicate.remaining()];
         duplicate.get(contents);
         return new String(contents);
     }
 }