[Cronet] Add callback wrapper classes to enforce API version checking.

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.impl;
 
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.net.TrafficStats;
 import android.os.Build;
@@ skipping 59 matching lines @@
     /**
      * Traffic stats tag to associate this requests' data use with. It's captured when the request
      * is created, so that applications doing work on behalf of another app can correctly attribute
      * that data use.
      */
     private final int mTrafficStatsTag;
     private final boolean mAllowDirectExecutor;
 
     /* These don't change with redirects */
     private String mInitialMethod;
-    private UploadDataProvider mUploadDataProvider;
+    private VersionSafeCallbacks.UploadDataProviderWrapper mUploadDataProvider;
     private Executor mUploadExecutor;
 
     /**
      * 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.
      */
     @StatusValues
     private volatile int mAdditionalStatusDetails = Status.INVALID;
 
     /* These change with redirects. */
     private String mCurrentUrl;
     private ReadableByteChannel mResponseChannel;
-    private UrlResponseInfo mUrlResponseInfo;
+    private UrlResponseInfoImpl 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
      * a redirect, which requires get-and-set semantics.
      * */
     private final AtomicReference<HttpURLConnection> mCurrentUrlConnection =
             new AtomicReference<>();
 
@@ skipping 132 matching lines @@
             throw new NullPointerException("Invalid UploadDataProvider.");
         }
         if (!mRequestHeaders.containsKey("Content-Type")) {
             throw new IllegalArgumentException(
                     "Requests with upload data must have a Content-Type.");
         }
         checkNotStarted();
         if (mInitialMethod == null) {
             mInitialMethod = "POST";
         }
-        this.mUploadDataProvider = uploadDataProvider;
+        this.mUploadDataProvider =
+                new VersionSafeCallbacks.UploadDataProviderWrapper(uploadDataProvider);
         if (mAllowDirectExecutor) {
             this.mUploadExecutor = executor;
         } else {
             this.mUploadExecutor = new DirectPreventingExecutor(executor);
         }
     }
 
     private enum SinkState {
         AWAITING_READ_RESULT,
         AWAITING_REWIND_RESULT,
         UPLOADING,
         NOT_STARTED,
     }
 
     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;
+        final VersionSafeCallbacks.UploadDataProviderWrapper mUploadProvider;
         ByteBuffer mBuffer;
         /** This holds the total bytes to send (the content-length). -1 if unknown. */
         long mTotalBytes;
         /** This holds the bytes written so far */
         long mWrittenBytes = 0;
 
         OutputStreamDataSink(final Executor userExecutor, Executor executor,
-                HttpURLConnection urlConnection, UploadDataProvider provider) {
+                HttpURLConnection urlConnection,
+                VersionSafeCallbacks.UploadDataProviderWrapper provider) {
             this.mUserUploadExecutor = new Executor() {
                 @Override
                 public void execute(Runnable runnable) {
                     try {
                         userExecutor.execute(runnable);
                     } catch (RejectedExecutionException e) {
                         enterUploadErrorState(e);
                     }
                 }
             };
@@ skipping 490 matching lines @@
             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);
+        mCallbackAsync.sendStatus(
+                new VersionSafeCallbacks.UrlRequestStatusListener(listener), status);
     }
 
     /** This wrapper ensures that callbacks are always called on the correct executor */
     private final class AsyncUrlRequestCallback {
-        final Callback mCallback;
+        final VersionSafeCallbacks.UrlRequestCallback mCallback;
         final Executor mUserExecutor;
         final Executor mFallbackExecutor;
 
         AsyncUrlRequestCallback(Callback callback, final Executor userExecutor) {
-            this.mCallback = callback;
+            this.mCallback = new VersionSafeCallbacks.UrlRequestCallback(callback);
             if (mAllowDirectExecutor) {
                 this.mUserExecutor = userExecutor;
                 this.mFallbackExecutor = null;
             } else {
                 mUserExecutor = new DirectPreventingExecutor(userExecutor);
                 mFallbackExecutor = userExecutor;
             }
         }
 
-        void sendStatus(final StatusListener listener, final int status) {
+        void sendStatus(
+                final VersionSafeCallbacks.UrlRequestStatusListener listener, final int status) {
             mUserExecutor.execute(new Runnable() {
                 @Override
                 public void run() {
                     listener.onStatus(status);
                 }
             });
         }
 
         void execute(CheckedRunnable runnable) {
             try {
@@ skipping 144 matching lines @@
                     // Can't throw directly from here, since the delegate executor could catch this
                     // exception.
                     mExecutedInline = new InlineExecutionProhibitedException();
                     return;
                 }
                 mCommand.run();
             }
         }
     }
 }