[Cronet] Upload support for async APIs

components/cronet/android/java/src/org/chromium/net/CronetUrlRequest.java

 // Copyright 2014 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.util.Log;
 import android.util.Pair;
 
 import org.chromium.base.CalledByNative;
@@ skipping 38 matching lines @@
      * decided a redirect will be followed.
      */
     private final List<String> mUrlChain = new ArrayList<String>();
 
     private final UrlRequestListener mListener;
     private final String mInitialUrl;
     private final int mPriority;
     private String mInitialMethod;
     private final HeadersList mRequestHeaders = new HeadersList();
 
+    private CronetUploadDataStream mUploadDataStream;
+
     private NativeResponseInfo mResponseInfo;
 
     /*
      * Listener callback is repeatedly called when data is received, so it is
      * cached as member variable.
      */
     private OnDataReceivedRunnable mOnDataReceivedTask;
 
     static final class HeadersList extends ArrayList<Pair<String, String>> {
     }
@@ skipping 181 matching lines @@
         if (header == null) {
             throw new NullPointerException("Invalid header name.");
         }
         if (value == null) {
             throw new NullPointerException("Invalid header value.");
         }
         mRequestHeaders.add(Pair.create(header, value));
     }
 
     @Override
+    public void setUploadDataProvider(UploadDataProvider uploadDataProvider, Executor executor) {
+        if (uploadDataProvider == null) {
+            throw new NullPointerException("Invalid UploadDataProvider.");
+        }
+        if (mInitialMethod == null) {
+            mInitialMethod = "POST";
+        }
+        mUploadDataStream = new CronetUploadDataStream(uploadDataProvider, executor);
+    }
+
+    @Override
     public void start() {
         synchronized (mUrlRequestAdapterLock) {
             checkNotStarted();
-            mUrlRequestAdapter = nativeCreateRequestAdapter(
-                    mRequestContext.getUrlRequestContextAdapter(),
-                    mInitialUrl,
-                    mPriority);
-            mRequestContext.onRequestStarted(this);
-            if (mInitialMethod != null) {
-                if (!nativeSetHttpMethod(mUrlRequestAdapter, mInitialMethod)) {
-                    destroyRequestAdapter();
-                    throw new IllegalArgumentException("Invalid http method "
-                            + mInitialMethod);
+
+            try {
+                mUrlRequestAdapter = nativeCreateRequestAdapter(
+                        mRequestContext.getUrlRequestContextAdapter(), mInitialUrl, mPriority);
+                mRequestContext.onRequestStarted(this);
+                if (mInitialMethod != null) {
+                    if (!nativeSetHttpMethod(mUrlRequestAdapter, mInitialMethod)) {
+                        throw new IllegalArgumentException("Invalid http method " + mInitialMethod);
+                    }
                 }
+
+                boolean hasContentType = false;
+                for (Pair<String, String> header : mRequestHeaders) {
+                    if (header.first.equalsIgnoreCase("Content-Type")
+                            && !header.second.isEmpty()) {
+                        hasContentType = true;
+                    }
+                    if (!nativeAddHeader(mUrlRequestAdapter, header.first, header.second)) {
+                        destroyRequestAdapter();
+                        throw new IllegalArgumentException(
+                                "Invalid header " + header.first + "=" + header.second);
+                    }
+                }
+                if (mUploadDataStream != null) {
+                    if (!hasContentType) {
+                        throw new IllegalArgumentException(
+                                "Requests with body must have a Content-Type.");
+                    }
+                    mUploadDataStream.attachToRequest(this, mUrlRequestAdapter);
+                }
+            } catch (RuntimeException e) {
+                // If there's an exception, cleanup and then throw the
+                // exception to the caller.
+                destroyRequestAdapter();
+                throw e;
             }
-            for (Pair<String, String> header : mRequestHeaders) {
-                if (!nativeAddHeader(mUrlRequestAdapter, header.first,
-                        header.second)) {
-                    destroyRequestAdapter();
-                    throw new IllegalArgumentException("Invalid header "
-                            + header.first + "=" + header.second);
-                }
-            }
+
             mStarted = true;
             nativeStart(mUrlRequestAdapter);
         }
     }
 
     @Override
     public void cancel() {
         synchronized (mUrlRequestAdapterLock) {
             if (mCanceled || !mStarted) {
                 return;
@@ skipping 115 matching lines @@
             cancel();
         }
         try {
             mListener.onFailed(this, mResponseInfo, requestError);
         } catch (Exception failException) {
             Log.e(CronetUrlRequestContext.LOG_TAG,
                     "Exception notifying of failed request", failException);
         }
     }
 
+    /**
+     * Called when UploadDataProvider encounters an error.
+     */
+    void onUploadException(Exception e) {
+        UrlRequestException uploadError =
+                new UrlRequestException("Exception received from UploadDataProvider", e);
+        Log.e(CronetUrlRequestContext.LOG_TAG, "Exception in upload method", e);
+        // Do not call into listener if request is canceled.
+        synchronized (mUrlRequestAdapterLock) {
+            if (isCanceled()) {
+                return;
+            }
+            cancel();
+        }
+        try {
+            mListener.onFailed(this, mResponseInfo, uploadError);
+        } catch (Exception failException) {
+            Log.e(CronetUrlRequestContext.LOG_TAG, "Exception notifying of failed upload",
+                    failException);
+        }
+    }
+
     ////////////////////////////////////////////////
     // Private methods called by the native code.
     // Always called on network thread.
     ////////////////////////////////////////////////
 
     /**
      * Called before following redirects. The redirect will automatically be
      * followed, unless the request is paused or canceled during this
      * callback. If the redirect response has a body, it will be ignored.
      * This will only be called between start and onResponseStarted.
@@ skipping 186 matching lines @@
             HeadersList headers);
 
     private native String nativeGetNegotiatedProtocol(long urlRequestAdapter);
 
     private native String nativeGetHttpStatusText(long urlRequestAdapter);
 
     private native boolean nativeGetWasCached(long urlRequestAdapter);
 
     private native long nativeGetTotalReceivedBytes(long urlRequestAdapter);
 }