Initial implementation of CronetBidirectionalStream.

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 70 matching lines @@
         }
 
         /**
          * Sets the HTTP method for the request. Returns builder to facilitate chaining.
          *
          * @param method the method to use for request. Default is 'POST'
          * @return the builder to facilitate chaining
          */
         public Builder setHttpMethod(String method) {
             if (method == null) {
-                throw new NullPointerException("Invalid method name.");
+                throw new NullPointerException("Method is required.");
             }
             mHttpMethod = method;
             return this;
         }
 
         /**
          * Adds a request header. Returns builder to facilitate chaining.
          *
          * @param header the header name
          * @param value the header value
@@ skipping 113 matching lines @@
          *     onSucceeded()} callback if {@link BidirectionalStream#write write()} was invoked with
          *     {@code endOfStream} set to {@code true}. The buffer's limit is not changed.
          */
         public abstract void onReadCompleted(
                 BidirectionalStream stream, UrlResponseInfo info, ByteBuffer buffer);
 
         /**
          * Invoked when data passed to {@link BidirectionalStream#write write()} is sent. The
          * buffer's position is updated to the end of the sent data. The buffer's limit is not
          * changed. Not all available data may have been sent, so the buffer's position is not
          * necessarily equal to its limit. To continue writing, call

[pauljensen, 2016/01/19 16:03:39]

is there any reason to require all callers to handle the case of partial writes?
 if our impl is known to always send it all, I feel like that is adding
unnecessary complexity to callers.  do we even envision changing this
requirement?  I imagine we could always implement this interface on an impl that
may do partial writes, but simply adding a condition to the OnWriteCompleted
callback such that is automatically calls write() again if not all data was
written.  I guess the question is whether embedders are going to benefit from
knowing that not all bytes were written and taking action on this.  Anyhow
probably something to kick down the road to another CL.

[mef, 2016/01/20 15:37:39]

Acknowledged. I agree, but I would wait until QUIC implementation and gRPC
integration before removing this.

          * {@link BidirectionalStream#write write()}.
          *
          * @param stream the stream on which the write completed
          * @param info the response information
          * @param buffer the buffer that was passed to {@link BidirectionalStream#write write()}.
          *     The buffer's position is set to the end of the sent data. The buffer's limit
          *     is not changed.
          */
         public abstract void onWriteCompleted(
                 BidirectionalStream stream, UrlResponseInfo info, ByteBuffer buffer);
@@ skipping 163 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();
 }