Upstream missing changes from HttpUrlRequest.java

components/cronet/android/java/src/org/chromium/net/HttpUrlConnectionUrlRequest.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.content.Context;
 import android.text.TextUtils;
 
 import org.apache.http.HttpStatus;
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.HttpURLConnection;
+import java.net.ProtocolException;
 import java.net.URL;
 import java.nio.ByteBuffer;
 import java.nio.channels.ReadableByteChannel;
 import java.nio.channels.WritableByteChannel;
+import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.zip.GZIPInputStream;
 
 /**
  * Network request using the HttpUrlConnection implementation.
@@ skipping 17 matching lines @@
     private final HttpUrlRequestListener mListener;
 
     private IOException mException;
 
     private HttpURLConnection mConnection;
 
     private long mOffset;
 
     private int mContentLength;
 
+    private long mUploadContentLength;
+
     private long mContentLengthLimit;
 
     private boolean mCancelIfContentLengthOverLimit;
 
     private boolean mContentLengthOverLimit;
 
     private boolean mSkippingToOffset;
 
     private long mSize;
 
     private String mPostContentType;
 
     private byte[] mPostData;
 
     private ReadableByteChannel mPostDataChannel;
 
     private String mContentType;
 
     private int mHttpStatusCode;
 
     private boolean mStarted;
 
     private boolean mCanceled;
 
+    private String mMethod;
+
     private InputStream mResponseStream;
 
     private final Object mLock;
 
     private static ExecutorService sExecutorService;
 
     private static final Object sExecutorServiceLock = new Object();
 
     HttpUrlConnectionUrlRequest(Context context, String url,
             int requestPriority, Map<String, String> headers,
@@ skipping 63 matching lines @@
         validateNotStarted();
         mPostContentType = contentType;
         mPostData = data;
         mPostDataChannel = null;
     }
 
     @Override
     public void setUploadChannel(String contentType,
             ReadableByteChannel channel, long contentLength) {
         validateNotStarted();
+        mUploadContentLength = contentLength;
         mPostContentType = contentType;
         mPostDataChannel = channel;
         mPostData = null;
     }
 
+
+    @Override
+    public void setHttpMethod(String method) {
+         validateNotStarted();
+         if (!("PUT".equals(method) || "POST".equals(method))) {
+             throw new IllegalArgumentException(
+                     "Only PUT and POST are allowed.");
+         }
+         mMethod = method;
+    }
+
     @Override
     public void start() {
         getExecutor().execute(new Runnable() {
             @Override
             public void run() {
                 startOnExecutorThread();
             }
         });
     }
 
     private void startOnExecutorThread() {
         boolean readingResponse = false;
         try {
             synchronized (mLock) {
                 if (mCanceled) {
                     return;
                 }
             }
 
             URL url = new URL(mUrl);
             mConnection = (HttpURLConnection)url.openConnection();
+            // If configured, use the provided http verb.
+            if (mMethod != null) {
+                try {
+                    mConnection.setRequestMethod(mMethod);
+                } catch (ProtocolException e) {
+                    // Since request hasn't started earlier, it
+                    // must be an illegal HTTP verb.
+                    throw new IllegalArgumentException(e);
+                }
+            }
             mConnection.setConnectTimeout(CONNECT_TIMEOUT);
             mConnection.setReadTimeout(READ_TIMEOUT);
             mConnection.setInstanceFollowRedirects(true);
             if (mHeaders != null) {
                 for (Entry<String, String> header : mHeaders.entrySet()) {
                     mConnection.setRequestProperty(header.getKey(),
                             header.getValue());
                 }
             }
 
@@ skipping 82 matching lines @@
             mConnection.setRequestProperty("Content-Type", mPostContentType);
         }
 
         OutputStream uploadStream = null;
         try {
             if (mPostData != null) {
                 mConnection.setFixedLengthStreamingMode(mPostData.length);
                 uploadStream = mConnection.getOutputStream();
                 uploadStream.write(mPostData);
             } else {
-                mConnection.setChunkedStreamingMode(MAX_CHUNK_SIZE);
+                mConnection.setFixedLengthStreamingMode(
+                        (int)mUploadContentLength);

[mmenke, 2014/07/11 20:04:05]

Not really a big fan of casting and just crossing fingers...Yes, we aren't going
to get a length of 2^31 or greater on Android, but downcasting like this still
seems a bad idea.  Could just throw an exception in setUploadChannel, or keep
the old code, or something...

[mef, 2014/07/14 15:02:17]

Done.

                 uploadStream = mConnection.getOutputStream();
                 byte[] bytes = new byte[MAX_CHUNK_SIZE];
                 ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);
                 while (mPostDataChannel.read(byteBuffer) > 0) {
                     byteBuffer.flip();
                     uploadStream.write(bytes, 0, byteBuffer.limit());
                     byteBuffer.clear();
                 }
             }
         } finally {
@@ skipping 139 matching lines @@
     public String getContentType() {
         return mContentType;
     }
 
 
     @Override
     public String getHeader(String name) {
         if (mConnection == null) {
             throw new IllegalStateException("Response headers not available");
         }
-        return mConnection.getHeaderField(name);
+        Map<String, List<String>> headerFields = mConnection.getHeaderFields();
+        if (headerFields != null) {
+            List<String> headerValues = headerFields.get(name);
+            if (headerValues != null) {
+                return TextUtils.join(", ", headerValues);
+            }
+        }
+        return null;
     }
 
     private void validateNotStarted() {
         if (mStarted) {
             throw new IllegalStateException("Request already started");
         }
     }
 }