Flush chunks on each upload read

components/cronet/android/api/src/org/chromium/net/JavaUrlRequest.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.annotation.TargetApi;
 import android.net.TrafficStats;
 import android.os.Build;
 import android.util.Log;
 
 import java.io.Closeable;
 import java.io.IOException;
+import java.io.OutputStream;
 import java.net.HttpURLConnection;
 import java.net.URI;
 import java.net.URL;
 import java.nio.ByteBuffer;
 import java.nio.channels.Channels;
 import java.nio.channels.ReadableByteChannel;
 import java.nio.channels.WritableByteChannel;
 import java.util.AbstractMap.SimpleEntry;
 import java.util.ArrayList;
 import java.util.Collections;
@@ skipping 229 matching lines @@
         UPLOADING,
         NOT_STARTED,
     }
 
     private final class OutputStreamDataSink implements UploadDataSink {
         final AtomicReference<SinkState> mSinkState = new AtomicReference<>(SinkState.NOT_STARTED);
         final Executor mUserUploadExecutor;
         final Executor mExecutor;
         final HttpURLConnection mUrlConnection;
         WritableByteChannel mOutputChannel;
+        OutputStream mUrlConnectionOutputStream;
         final UploadDataProvider mUploadProvider;
         ByteBuffer mBuffer;
         /** This holds the total bytes to send (the content-length). -1 if unknown. */
         long mTotalBytes;
         /** This holds the bytes written so far */
         long mWrittenBytes = 0;
 
         OutputStreamDataSink(final Executor userExecutor, Executor executor,
                 HttpURLConnection urlConnection, UploadDataProvider provider) {
             this.mUserUploadExecutor = new Executor() {
@@ skipping 23 matching lines @@
                     mBuffer.flip();
                     if (mTotalBytes != -1 && mTotalBytes - mWrittenBytes < mBuffer.remaining()) {
                         enterUploadErrorState(new IllegalArgumentException(String.format(
                                 "Read upload data length %d exceeds expected length %d",
                                 mWrittenBytes + mBuffer.remaining(), mTotalBytes)));
                         return;
                     }
                     while (mBuffer.hasRemaining()) {
                         mWrittenBytes += mOutputChannel.write(mBuffer);
                     }
+                    // Forces a chunk to be sent, rather than buffering to the DEFAULT_CHUNK_LENGTH.
+                    // This allows clients to trickle-upload bytes as they become available without
+                    // introducing latency due to buffering.
+                    mUrlConnectionOutputStream.flush();
+
                     if (mWrittenBytes < mTotalBytes || (mTotalBytes == -1 && !finalChunk)) {
                         mBuffer.clear();
                         mSinkState.set(SinkState.AWAITING_READ_RESULT);
                         executeOnUploadExecutor(new CheckedRunnable() {
                             @Override
                             public void run() throws Exception {
                                 mUploadProvider.read(OutputStreamDataSink.this, mBuffer);
                             }
                         });
                     } else if (mTotalBytes == -1) {
@@ skipping 28 matching lines @@
         }
 
         void startRead() {
             mExecutor.execute(errorSetting(new CheckedRunnable() {
                 @Override
                 public void run() throws Exception {
                     if (mOutputChannel == null) {
                         mAdditionalStatusDetails = Status.CONNECTING;
                         mUrlConnection.connect();
                         mAdditionalStatusDetails = Status.SENDING_REQUEST;
-                        mOutputChannel = Channels.newChannel(mUrlConnection.getOutputStream());
+                        mUrlConnectionOutputStream = mUrlConnection.getOutputStream();
+                        mOutputChannel = Channels.newChannel(mUrlConnectionOutputStream);
                     }
                     mSinkState.set(SinkState.AWAITING_READ_RESULT);
                     executeOnUploadExecutor(new CheckedRunnable() {
                         @Override
                         public void run() throws Exception {
                             mUploadProvider.read(OutputStreamDataSink.this, mBuffer);
                         }
                     });
                 }
             }));
@@ skipping 584 matching lines @@
                     // Can't throw directly from here, since the delegate executor could catch this
                     // exception.
                     mExecutedInline = new InlineExecutionProhibitedException();
                     return;
                 }
                 mCommand.run();
             }
         }
     }
 }