Remove BidirectionalStream.Builder.disableAutoFlush

components/cronet/android/java/src/org/chromium/net/impl/CronetBidirectionalStream.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.impl;
 
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
@@ skipping 64 matching lines @@
         WRITING_DONE,
     }
 
     private final CronetUrlRequestContext mRequestContext;
     private final Executor mExecutor;
     private final Callback mCallback;
     private final String mInitialUrl;
     private final int mInitialPriority;
     private final String mInitialMethod;
     private final String mRequestHeaders[];
-    private final boolean mDisableAutoFlush;
     private final boolean mDelayRequestHeadersUntilFirstFlush;
 
     /*
      * Synchronizes access to mNativeStream, mReadState and mWriteState.
      */
     private final Object mNativeStreamLock = new Object();
 
     @GuardedBy("mNativeStreamLock")
     // Pending write data.
     private LinkedList<ByteBuffer> mPendingData;
@@ skipping 116 matching lines @@
                 }
             } catch (Exception e) {
                 onCallbackException(e);
             }
         }
     }
 
     CronetBidirectionalStream(CronetUrlRequestContext requestContext, String url,
             @BidirectionalStream.Builder.StreamPriority int priority, Callback callback,
             Executor executor, String httpMethod, List<Map.Entry<String, String>> requestHeaders,
-            boolean disableAutoFlush, boolean delayRequestHeadersUntilNextFlush) {
+            boolean delayRequestHeadersUntilNextFlush) {
         mRequestContext = requestContext;
         mInitialUrl = url;
         mInitialPriority = convertStreamPriority(priority);
         mCallback = callback;
         mExecutor = executor;
         mInitialMethod = httpMethod;
         mRequestHeaders = stringsFromHeaderList(requestHeaders);
-        mDisableAutoFlush = disableAutoFlush;
         mDelayRequestHeadersUntilFirstFlush = delayRequestHeadersUntilNextFlush;
         mPendingData = new LinkedList<>();
         mFlushData = new LinkedList<>();
     }
 
     @Override
     public void start() {
         synchronized (mNativeStreamLock) {
             if (mReadState != State.NOT_STARTED) {
                 throw new IllegalStateException("Stream is already started.");
@@ skipping 58 matching lines @@
             if (mEndOfStreamWritten) {
                 throw new IllegalArgumentException("Write after writing end of stream.");
             }
             if (isDoneLocked()) {
                 return;
             }
             mPendingData.add(buffer);
             if (endOfStream) {
                 mEndOfStreamWritten = true;
             }
-            if (!mDisableAutoFlush) {
-                flushLocked();
-            }
         }
     }
 
     @Override
     public void flush() {
         synchronized (mNativeStreamLock) {
-            flushLocked();
+            if (isDoneLocked()
+                    || (mWriteState != State.WAITING_FOR_FLUSH && mWriteState != State.WRITING)) {
+                return;
+            }
+            if (mPendingData.isEmpty() && mFlushData.isEmpty()) {
+                // If there is no pending write when flush() is called, see if
+                // request headers need to be flushed.
+                if (!mRequestHeadersSent) {
+                    mRequestHeadersSent = true;
+                    nativeSendRequestHeaders(mNativeStream);
+                    if (!doesMethodAllowWriteData(mInitialMethod)) {
+                        mWriteState = State.WRITING_DONE;
+                    }
+                }
+                return;
+            }
+
+            assert !mPendingData.isEmpty() || !mFlushData.isEmpty();
+
+            // Move buffers from mPendingData to the flushing queue.
+            if (!mPendingData.isEmpty()) {
+                mFlushData.addAll(mPendingData);
+                mPendingData.clear();
+            }
+
+            if (mWriteState == State.WRITING) {
+                // If there is a write already pending, wait until onWritevCompleted is
+                // called before pushing data to the native stack.
+                return;
+            }
+            sendFlushDataLocked();
         }
     }
 
-    @SuppressWarnings("GuardedByChecker")
-    private void flushLocked() {
-        if (isDoneLocked()
-                || (mWriteState != State.WAITING_FOR_FLUSH && mWriteState != State.WRITING)) {
-            return;
-        }
-        if (mPendingData.isEmpty() && mFlushData.isEmpty()) {
-            // If there is no pending write when flush() is called, see if
-            // request headers need to be flushed.
-            if (!mRequestHeadersSent) {
-                mRequestHeadersSent = true;
-                nativeSendRequestHeaders(mNativeStream);
-                if (!doesMethodAllowWriteData(mInitialMethod)) {
-                    mWriteState = State.WRITING_DONE;
-                }
-            }
-            return;
-        }
-
-        assert !mPendingData.isEmpty() || !mFlushData.isEmpty();
-
-        // Move buffers from mPendingData to the flushing queue.
-        if (!mPendingData.isEmpty()) {
-            mFlushData.addAll(mPendingData);
-            mPendingData.clear();
-        }
-
-        if (mWriteState == State.WRITING) {
-            // If there is a write already pending, wait until onWritevCompleted is
-            // called before pushing data to the native stack.
-            return;
-        }
-        sendFlushDataLocked();
-    }
-
     // Helper method to send buffers in mFlushData. Caller needs to acquire
     // mNativeStreamLock and make sure mWriteState is WAITING_FOR_FLUSH and
     // mFlushData queue isn't empty.
     @SuppressWarnings("GuardedByChecker")
     private void sendFlushDataLocked() {
         assert mWriteState == State.WAITING_FOR_FLUSH;
         int size = mFlushData.size();
         ByteBuffer[] buffers = new ByteBuffer[size];
         int[] positions = new int[size];
         int[] limits = new int[size];
         for (int i = 0; i < size; i++) {
             ByteBuffer buffer = mFlushData.poll();
             buffers[i] = buffer;
             positions[i] = buffer.position();
             limits[i] = buffer.limit();
         }
         assert mFlushData.isEmpty();
         assert buffers.length >= 1;
         mWriteState = State.WRITING;
+        mRequestHeadersSent = true;

[kapishnikov, 2016/08/17 22:30:56]

Nice catch!

         if (!nativeWritevData(mNativeStream, buffers, positions, limits,
                     mEndOfStreamWritten && mPendingData.isEmpty())) {
             // Still waiting on flush. This is just to have consistent
             // behavior with the other error cases.
             mWriteState = State.WAITING_FOR_FLUSH;
             throw new IllegalArgumentException("Unable to call native writev.");
         }
     }
 
     /**
@@ skipping 380 matching lines @@
     private native boolean nativeReadData(
             long nativePtr, ByteBuffer byteBuffer, int position, int limit);
 
     @NativeClassQualifiedName("CronetBidirectionalStreamAdapter")
     private native boolean nativeWritevData(long nativePtr, ByteBuffer[] buffers, int[] positions,
             int[] limits, boolean endOfStream);
 
     @NativeClassQualifiedName("CronetBidirectionalStreamAdapter")
     private native void nativeDestroy(long nativePtr, boolean sendOnCanceled);
 }