[Cronet] Make delaying sending request headers explicit in bidirectional stream

components/cronet/android/api/src/org/chromium/net/BidirectionalStream.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.support.annotation.IntDef;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ skipping 30 matching lines @@
         // List of request headers, stored as header field name and value pairs.
         private final ArrayList<Map.Entry<String, String>> mRequestHeaders =
                 new ArrayList<Map.Entry<String, String>>();
 
         // HTTP method for the request. Default to POST.
         private String mHttpMethod = "POST";
         // Priority of the stream. Default is medium.
         @StreamPriority private int mPriority = STREAM_PRIORITY_MEDIUM;
 
         private boolean mDisableAutoFlush;
+        private boolean mDelayHeadersUntilNextWrite;
 
         /**
          * Creates a builder for {@link BidirectionalStream} objects. All callbacks for
          * generated {@code BidirectionalStream} objects will be invoked on
          * {@code executor}. {@code executor} must not run tasks on the
          * current thread, otherwise the networking operations may block and exceptions
          * may be thrown at shutdown time.
          *
          * @param url the URL for the generated stream
          * @param callback the {@link Callback} object that gets invoked upon different events
@@ skipping 106 matching lines @@
          *
          * @param disableAutoFlush if true, auto flush will be disabled.
          * @return the builder to facilitate chaining.
          */
         public Builder disableAutoFlush(boolean disableAutoFlush) {
             mDisableAutoFlush = disableAutoFlush;
             return this;
         }
 
         /**
+         * Delays sending request headers until the next {@link write()} is invoked.
+         * This flag is currently only respected when QUIC is negotiated.
+         * When true, QUIC will send request header frame along with data frame(s)
+         * as a single packet when possible.
+         *
+         * @param delayHeadersUntilNextWrite if true, sending request headers will
+         *         be delayed until the next write() is invoked.
+         * @return the builder to facilitate chaining.
+         */
+        public Builder delayHeadersUntilNextWrite(boolean delayHeadersUntilNextWrite) {

[mef, 2016/05/23 14:57:26]

Does it have an effect if disableAutoFlush is false?

+            mDelayHeadersUntilNextWrite = delayHeadersUntilNextWrite;
+            return this;
+        }
+
+        /**
          * Creates a {@link BidirectionalStream} using configuration from this
          * {@link Builder}. The returned {@code BidirectionalStream} can then be started
          * by calling {@link BidirectionalStream#start}.
          *
          * @return constructed {@link BidirectionalStream} using configuration from
          *         this {@link Builder}
          */
         public BidirectionalStream build() {
             return mCronetEngine.createBidirectionalStream(mUrl, mCallback, mExecutor, mHttpMethod,
-                    mRequestHeaders, mPriority, mDisableAutoFlush);
+                    mRequestHeaders, mPriority, mDisableAutoFlush, mDelayHeadersUntilNextWrite);
         }
     }
 
     /**
      * Callback class used to receive callbacks from a {@link BidirectionalStream}.
      */
     public abstract static class Callback {
         /**
          * Invoked when the stream is ready for reading and writing.
          * Consumer may call {@link BidirectionalStream#read read()} to start reading data.
@@ skipping 221 matching lines @@
     /**
      * Returns {@code true} if the stream was successfully started and is now
      * done (succeeded, canceled, or failed).
      *
      * @return {@code true} if the stream was successfully started and is now
      *         done (completed, canceled, or failed), otherwise returns {@code false}
      *         to indicate stream is not yet started or is in progress.
      */
     public abstract boolean isDone();
 }