Cronet API Refactoring

components/cronet/android/java/src/org/chromium/net/impl/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;
+package org.chromium.net.impl;
 
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.net.TrafficStats;
 import android.os.Build;
+
 import android.util.Log;
 
+import org.chromium.net.InlineExecutionProhibitedException;
+import org.chromium.net.UploadDataProvider;
+import org.chromium.net.UploadDataSink;
+import org.chromium.net.UrlRequestException;
+import org.chromium.net.UrlResponseInfo;
+
 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;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
 import java.util.concurrent.Executor;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * Pure java UrlRequest, backed by {@link HttpURLConnection}.
  */
 @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH) // TrafficStats only available on ICS
-final class JavaUrlRequest implements UrlRequest {
+final class JavaUrlRequest extends UrlRequestBase {
     private static final String X_ANDROID = "X-Android";
     private static final String X_ANDROID_SELECTED_TRANSPORT = "X-Android-Selected-Transport";
     private static final String TAG = "JavaUrlConnection";
     private static final int DEFAULT_UPLOAD_BUFFER_SIZE = 8192;
     private static final int DEFAULT_CHUNK_LENGTH = DEFAULT_UPLOAD_BUFFER_SIZE;
     private static final String USER_AGENT = "User-Agent";
     private final AsyncUrlRequestCallback mCallbackAsync;
     private final Executor mExecutor;
     private final String mUserAgent;
     private final Map<String, String> mRequestHeaders =
@@ skipping 27 matching lines @@
     /**
      * Holds a subset of StatusValues - {@link State#STARTED} can represent
      * {@link Status#SENDING_REQUEST} or {@link Status#WAITING_FOR_RESPONSE}. While the distinction
      * isn't needed to implement the logic in this class, it is needed to implement
      * {@link #getStatus(StatusListener)}.
      *
      * <p>Concurrency notes - this value is not atomically updated with mState, so there is some
      * risk that we'd get an inconsistent snapshot of both - however, it also happens that this
      * value is only used with the STARTED state, so it's inconsequential.
      */
-    @Status.StatusValues private volatile int mAdditionalStatusDetails = Status.INVALID;
+    @StatusValues
+    private volatile int mAdditionalStatusDetails = Status.INVALID;
 
     /* These change with redirects. */
     private String mCurrentUrl;
     private ReadableByteChannel mResponseChannel;
     private UrlResponseInfo mUrlResponseInfo;
     private String mPendingRedirectUrl;
     /**
      * The happens-before edges created by the executor submission and AtomicReference setting are
      * sufficient to guarantee the correct behavior of this field; however, this is an
      * AtomicReference so that we can cleanly dispose of a new connection if we're cancelled during
@@ skipping 152 matching lines @@
         }
     }
 
     private enum SinkState {
         AWAITING_READ_RESULT,
         AWAITING_REWIND_RESULT,
         UPLOADING,
         NOT_STARTED,
     }
 
-    private final class OutputStreamDataSink implements UploadDataSink {
+    private final class OutputStreamDataSink extends 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;
@@ skipping 481 matching lines @@
     public boolean isDone() {
         State state = mState.get();
         return state == State.COMPLETE | state == State.ERROR | state == State.CANCELLED;
     }
 
     @Override
     public void getStatus(StatusListener listener) {
         State state = mState.get();
         int extraStatus = this.mAdditionalStatusDetails;
 
-        @Status.StatusValues final int status;
+        @StatusValues
+        final int status;
         switch (state) {
             case ERROR:
             case COMPLETE:
             case CANCELLED:
             case NOT_STARTED:
                 status = Status.INVALID;
                 break;
             case STARTED:
                 status = extraStatus;
                 break;
             case REDIRECT_RECEIVED:
             case AWAITING_FOLLOW_REDIRECT:
             case AWAITING_READ:
                 status = Status.IDLE;
                 break;
             case READING:
                 status = Status.READING_RESPONSE;
                 break;
             default:
                 throw new IllegalStateException("Switch is exhaustive: " + state);
         }
 
         mCallbackAsync.sendStatus(listener, status);
     }
 
     /** This wrapper ensures that callbacks are always called on the correct executor */
     private final class AsyncUrlRequestCallback {
-        final UrlRequest.Callback mCallback;
+        final Callback mCallback;
         final Executor mUserExecutor;
         final Executor mFallbackExecutor;
 
         AsyncUrlRequestCallback(Callback callback, final Executor userExecutor) {
             this.mCallback = callback;
             if (mAllowDirectExecutor) {
                 this.mUserExecutor = userExecutor;
                 this.mFallbackExecutor = null;
             } else {
                 mUserExecutor = new DirectPreventingExecutor(userExecutor);
@@ skipping 159 matching lines @@
                     // Can't throw directly from here, since the delegate executor could catch this
                     // exception.
                     mExecutedInline = new InlineExecutionProhibitedException();
                     return;
                 }
                 mCommand.run();
             }
         }
     }
 }