Cronet API Refactoring

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;
 import org.chromium.base.annotations.NativeClassQualifiedName;
 import org.chromium.net.BidirectionalStream;
 import org.chromium.net.CronetException;
-import org.chromium.net.Preconditions;
+import org.chromium.net.ExperimentalBidirectionalStream;
 import org.chromium.net.QuicException;
 import org.chromium.net.RequestFinishedInfo;
 import org.chromium.net.RequestPriority;
 import org.chromium.net.UrlRequestException;
 import org.chromium.net.UrlResponseInfo;
 
 import java.nio.ByteBuffer;
 import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Executor;
 import java.util.concurrent.RejectedExecutionException;
 
 import javax.annotation.concurrent.GuardedBy;
 
 /**
  * {@link BidirectionalStream} implementation using Chromium network stack.
  * All @CalledByNative methods are called on the native network thread
  * and post tasks with callback calls onto Executor. Upon returning from callback, the native
  * stream is called on Executor thread and posts native tasks to the native network thread.
  */
 @JNINamespace("cronet")
 @VisibleForTesting
-public class CronetBidirectionalStream extends BidirectionalStream {
+public class CronetBidirectionalStream extends ExperimentalBidirectionalStream {
     /**
      * States of BidirectionalStream are tracked in mReadState and mWriteState.
      * The write state is separated out as it changes independently of the read state.
      * There is one initial state: State.NOT_STARTED. There is one normal final state:
      * State.SUCCESS, reached after State.READING_DONE and State.WRITING_DONE. There are two
      * exceptional final states: State.CANCELED and State.ERROR, which can be reached from
      * any other non-final state.
      */
     private enum State {
         /* Initial state, stream not started. */
@@ skipping 164 matching lines @@
                 if (maybeOnSucceeded) {
                     maybeOnSucceededOnExecutor();
                 }
             } 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,
+            @CronetEngineBase.StreamPriority int priority, Callback callback, Executor executor,
+            String httpMethod, List<Map.Entry<String, String>> requestHeaders,
             boolean delayRequestHeadersUntilNextFlush, Collection<Object> requestAnnotations) {
         mRequestContext = requestContext;
         mInitialUrl = url;
         mInitialPriority = convertStreamPriority(priority);
         mCallback = callback;
         mExecutor = executor;
         mInitialMethod = httpMethod;
         mRequestHeaders = stringsFromHeaderList(requestHeaders);
         mDelayRequestHeadersUntilFirstFlush = delayRequestHeadersUntilNextFlush;
         mPendingData = new LinkedList<>();
@@ skipping 438 matching lines @@
     private static String[] stringsFromHeaderList(List<Map.Entry<String, String>> headersList) {
         String headersArray[] = new String[headersList.size() * 2];
         int i = 0;
         for (Map.Entry<String, String> requestHeader : headersList) {
             headersArray[i++] = requestHeader.getKey();
             headersArray[i++] = requestHeader.getValue();
         }
         return headersArray;
     }
 
-    private static int convertStreamPriority(
-            @BidirectionalStream.Builder.StreamPriority int priority) {
+    private static int convertStreamPriority(@CronetEngineBase.StreamPriority int priority) {
         switch (priority) {
             case Builder.STREAM_PRIORITY_IDLE:
                 return RequestPriority.IDLE;
             case Builder.STREAM_PRIORITY_LOWEST:
                 return RequestPriority.LOWEST;
             case Builder.STREAM_PRIORITY_LOW:
                 return RequestPriority.LOW;
             case Builder.STREAM_PRIORITY_MEDIUM:
                 return RequestPriority.MEDIUM;
             case Builder.STREAM_PRIORITY_HIGHEST:
@@ skipping 104 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);
 }