Merge 271992 "Upstream changes to:"

components/cronet/android/java/src/org/chromium/net/UrlRequest.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 org.apache.http.conn.ConnectTimeoutException;
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 
@@ skipping 26 matching lines @@
     private final WritableByteChannel mSink;
     private Map<String, String> mAdditionalHeaders;
     private boolean mPostBodySet;
     private ReadableByteChannel mPostBodyChannel;
     private WritableByteChannel mOutputChannel;
     private IOException mSinkException;
     private volatile boolean mStarted;
     private volatile boolean mCanceled;
     private volatile boolean mRecycled;
     private volatile boolean mFinished;
+    private boolean mHeadersAvailable;
     private String mContentType;
     private long mContentLength;
     private Semaphore mAppendChunkSemaphore;
     private final ContextLock mLock;
 
     /**
      * Native peer object, owned by UrlRequest.
      */
     private long mUrlRequestPeer;
 
@@ skipping 73 matching lines @@
             mPostBodySet = true;
         }
         mAppendChunkSemaphore = new Semaphore(0);
     }
 
     public WritableByteChannel getSink() {
         return mSink;
     }
 
     public void start() {
-        synchronized (mLock) {
-            if (mCanceled) {
-                return;
+        try {
+            synchronized (mLock) {
+                if (mCanceled) {
+                    return;
+                }
+
+                validateNotStarted();
+                validateNotRecycled();
+
+                mStarted = true;
+
+                if (mHeaders != null && !mHeaders.isEmpty()) {
+                    for (Entry<String, String> entry : mHeaders.entrySet()) {
+                        nativeAddHeader(mUrlRequestPeer, entry.getKey(),
+                                entry.getValue());
+                    }
+                }
+
+                if (mAdditionalHeaders != null && !mAdditionalHeaders.isEmpty()) {
+                    for (Entry<String, String> entry :
+                            mAdditionalHeaders.entrySet()) {
+                        nativeAddHeader(mUrlRequestPeer, entry.getKey(),
+                                entry.getValue());
+                    }
+                }
+
+                nativeStart(mUrlRequestPeer);
             }
 
-            validateNotStarted();
-            validateNotRecycled();
-
-            mStarted = true;
-
-            if (mHeaders != null && !mHeaders.isEmpty()) {
-                for (Entry<String, String> entry : mHeaders.entrySet()) {
-                    nativeAddHeader(mUrlRequestPeer, entry.getKey(),
-                            entry.getValue());
+            if (mPostBodyChannel != null) {
+                uploadFromChannel(mPostBodyChannel);
+            }
+        } finally {
+            if (mPostBodyChannel != null) {
+                try {
+                    mPostBodyChannel.close();
+                } catch (IOException e) {
+                    // Ignore
                 }
             }
-
-            if (mAdditionalHeaders != null && !mAdditionalHeaders.isEmpty()) {
-                for (Entry<String, String> entry :
-                        mAdditionalHeaders.entrySet()) {
-                    nativeAddHeader(mUrlRequestPeer, entry.getKey(),
-                            entry.getValue());
-                }
-            }
-
-            nativeStart(mUrlRequestPeer);
-        }
-
-        if (mPostBodyChannel != null) {
-            uploadFromChannel(mPostBodyChannel);
         }
     }
 
     /**
      * Uploads data from a {@code ReadableByteChannel} using chunked transfer
      * encoding. The native call to append a chunk is asynchronous so a
      * semaphore is used to delay writing into the buffer again until chromium
      * is finished with it.
      *
      * @param channel the channel to read data from.
@@ skipping 30 matching lines @@
                 // Acquire permit before writing to the buffer again to ensure
                 // chromium is done with it.
                 mAppendChunkSemaphore.acquire();
             } while (!lastChunk && !mFinished);
         } catch (IOException e) {
             mSinkException = e;
             cancel();
         } catch (InterruptedException e) {
             mSinkException = new IOException(e);
             cancel();
-        } finally {
-            try {
-                mPostBodyChannel.close();
-            } catch (IOException ignore) {
-                ;
-            }
         }
     }
 
     public void cancel() {
         synchronized (mLock) {
             if (mCanceled) {
                 return;
             }
 
             mCanceled = true;
@@ skipping 60 matching lines @@
      * server returns the wrong number, which happens even with Google servers.
      */
     public long getContentLength() {
         return mContentLength;
     }
 
     public String getContentType() {
         return mContentType;
     }
 
+    public String getHeader(String name) {
+        validateHeadersAvailable();
+        return nativeGetHeader(mUrlRequestPeer, name);
+    }
+
     /**
      * A callback invoked when appending a chunk to the request has completed.
      */
     @CalledByNative
     protected void onAppendChunkCompleted() {
         mAppendChunkSemaphore.release();
     }
 
     /**
      * A callback invoked when the first chunk of the response has arrived.
      */
     @CalledByNative
     protected void onResponseStarted() {
         mContentType = nativeGetContentType(mUrlRequestPeer);
         mContentLength = nativeGetContentLength(mUrlRequestPeer);
+        mHeadersAvailable = true;
     }
 
     /**
      * A callback invoked when the response has been fully consumed.
      */
     protected void onRequestComplete() {
     }
 
     /**
      * Consumes a portion of the response.
@@ skipping 52 matching lines @@
             throw new IllegalStateException("Request already started");
         }
     }
 
     private void validatePostBodyNotSet() {
         if (mPostBodySet) {
             throw new IllegalStateException("Post Body already set");
         }
     }
 
+
+    private void validateHeadersAvailable() {
+        if (!mHeadersAvailable) {
+            throw new IllegalStateException("Response headers not available");
+        }
+    }
+
     public String getUrl() {
         return mUrl;
     }
 
     private native long nativeCreateRequestPeer(long urlRequestContextPeer,
             String url, int priority);
 
     private native void nativeAddHeader(long urlRequestPeer, String name,
             String value);
 
@@ skipping 14 matching lines @@
 
     private native int nativeGetErrorCode(long urlRequestPeer);
 
     private native int nativeGetHttpStatusCode(long urlRequestPeer);
 
     private native String nativeGetErrorString(long urlRequestPeer);
 
     private native String nativeGetContentType(long urlRequestPeer);
 
     private native long nativeGetContentLength(long urlRequestPeer);
+
+    private native String nativeGetHeader(long urlRequestPeer, String name);
 }