Allow direct executors in cronet.

components/cronet/android/java/src/org/chromium/net/impl/CronetUploadDataStream.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.util.Log;
 
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
@@ skipping 37 matching lines @@
                 if (mUploadDataStreamAdapter == 0) {
                     return;
                 }
                 checkState(UserCallback.NOT_IN_CALLBACK);
                 if (mByteBuffer == null) {
                     throw new IllegalStateException("Unexpected readData call. Buffer is null");
                 }
                 mInWhichUserCallback = UserCallback.READ;
             }
             try {
+                checkCallingThread();
                 mDataProvider.read(CronetUploadDataStream.this, mByteBuffer);
             } catch (Exception exception) {
                 onError(exception);
             }
         }
     };
 
     // ByteBuffer created in the native code and passed to
     // UploadDataProvider for reading. It is only valid from the
     // call to mDataProvider.read until onError or onReadSucceeded.
@@ skipping 55 matching lines @@
             @Override
             public void run() {
                 synchronized (mLock) {
                     if (mUploadDataStreamAdapter == 0) {
                         return;
                     }
                     checkState(UserCallback.NOT_IN_CALLBACK);
                     mInWhichUserCallback = UserCallback.REWIND;
                 }
                 try {
+                    checkCallingThread();
                     mDataProvider.rewind(CronetUploadDataStream.this);
                 } catch (Exception exception) {
                     onError(exception);
                 }
             }
         };
         postTaskToExecutor(task);
     }
 
+    private void checkCallingThread() {
+        if (mRequest != null) {
+            mRequest.checkCallingThread();
+        }
+    }
+
     @GuardedBy("mLock")
     private void checkState(UserCallback mode) {
         if (mInWhichUserCallback != mode) {
             throw new IllegalStateException(
                     "Expected " + mode + ", but was " + mInWhichUserCallback);
         }
     }
 
     /**
      * Called when the native UploadDataStream is destroyed.  At this point,
      * the native adapter needs to be destroyed, but only after any pending
      * read operation completes, as the adapter owns the read buffer.
      */
     @SuppressWarnings("unused")
     @CalledByNative
     void onUploadDataStreamDestroyed() {
         destroyAdapter();
     }
 
     /**
      * Helper method called when an exception occurred. This method resets
      * states and propagates the error to the request.
      */
     private void onError(Throwable exception) {
+        final boolean sendClose;
         synchronized (mLock) {
             if (mInWhichUserCallback == UserCallback.NOT_IN_CALLBACK) {
                 throw new IllegalStateException(
                         "There is no read or rewind or length check in progress.");
             }
+            sendClose = mInWhichUserCallback == UserCallback.GET_LENGTH;
             mInWhichUserCallback = UserCallback.NOT_IN_CALLBACK;
             mByteBuffer = null;
             destroyAdapterIfPostponed();
         }
+        // Failure before length is obtained means that the request has failed before the
+        // adapter has been initialized. Close the UploadDataProvider. This is safe to call
+        // here since failure during getLength can only happen on the user's executor.
+        if (sendClose) {
+            try {
+                mDataProvider.close();
+            } catch (Exception e) {
+                Log.e(TAG, "Failure closing data provider", e);
+            }
+        }
 
         // Just fail the request - simpler to fail directly, and
         // UploadDataStream only supports failing during initialization, not
         // while reading. The request is smart enough to handle the case where
         // it was already canceled by the embedder.
         mRequest.onUploadException(exception);
     }
 
     @Override
     public void onReadSucceeded(boolean lastChunk) {
@@ skipping 82 matching lines @@
             nativeDestroy(mUploadDataStreamAdapter);
             mUploadDataStreamAdapter = 0;
             if (mOnDestroyedCallbackForTesting != null) {
                 mOnDestroyedCallbackForTesting.run();
             }
         }
         postTaskToExecutor(new Runnable() {
             @Override
             public void run() {
                 try {
+                    checkCallingThread();
                     mDataProvider.close();
-                } catch (IOException e) {
+                } catch (Exception e) {
                     Log.e(TAG, "Exception thrown when closing", e);
                 }
             }
         });
     }
 
     /**
      * Destroys the native adapter if the destruction is postponed due to a
      * pending read, which has since completed. Caller needs to be on executor
      * thread.
      */
     private void destroyAdapterIfPostponed() {
         synchronized (mLock) {
             if (mInWhichUserCallback == UserCallback.READ) {
                 throw new IllegalStateException(
                         "Method should not be called when read has not completed.");
             }
             if (mDestroyAdapterPostponed) {
                 destroyAdapter();
             }
         }
     }
 
     /**
-     * Initializes upload length by getting it from data provider. Always called
-     * on executor thread to allow getLength() to block and/or report errors.
+     * Initializes upload length by getting it from data provider. Submits to
+     * the user's executor thread to allow getLength() to block and/or report errors.
      * If data provider throws an exception, then it is reported to the request.
      * No native calls to urlRequest are allowed as this is done before request
      * start, so native object may not exist.
      */
     void initializeWithRequest(final CronetUrlRequest urlRequest) {
         synchronized (mLock) {
             mRequest = urlRequest;
             mInWhichUserCallback = UserCallback.GET_LENGTH;
         }
         try {
+            urlRequest.checkCallingThread();
             mLength = mDataProvider.getLength();
             mRemainingLength = mLength;
         } catch (Throwable t) {
             onError(t);
         }
         synchronized (mLock) {
             mInWhichUserCallback = UserCallback.NOT_IN_CALLBACK;
         }
     }
 
@@ skipping 37 matching lines @@
 
     @NativeClassQualifiedName("CronetUploadDataStreamAdapter")
     private native void nativeOnReadSucceeded(long nativePtr, int bytesRead, boolean finalChunk);
 
     @NativeClassQualifiedName("CronetUploadDataStreamAdapter")
     private native void nativeOnRewindSucceeded(long nativePtr);
 
     @NativeClassQualifiedName("CronetUploadDataStreamAdapter")
     private static native void nativeDestroy(long nativePtr);
 }