WIP: Some cronet modifications for the AndroidGSA

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 android.util.Log;
+
 import org.apache.http.conn.ConnectTimeoutException;
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.UnknownHostException;
 import java.nio.ByteBuffer;
 import java.nio.channels.ReadableByteChannel;
 import java.nio.channels.WritableByteChannel;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.concurrent.Semaphore;
 
 /**
  * Network request using the native http stack implementation.
  */
 @JNINamespace("cronet")
 public class UrlRequest {
+    private static final String TAG = "UrlRequest";
+    private static final boolean DBG = false;
+
     private static final class ContextLock {
     }
 
     private static final int UPLOAD_BYTE_BUFFER_SIZE = 32768;
 
     private final UrlRequestContext mRequestContext;
     private final String mUrl;
     private final int mPriority;
     private final Map<String, String> mHeaders;
     private final WritableByteChannel mSink;
@@ skipping 78 matching lines @@
     /**
      * Sets a readable byte channel to upload as part of a POST request.
      *
      * @param contentType MIME type of the post content or null if this is not a
      *            POST request.
      * @param channel The channel to read to read upload data from if this is a
      *            POST request.
      */
     public void setUploadChannel(String contentType,
             ReadableByteChannel channel) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+
+    public WritableByteChannel enableUpload(String contentType) {
         synchronized (mLock) {
             validateNotStarted();
             validatePostBodyNotSet();
             nativeBeginChunkedUpload(mUrlRequestPeer, contentType);
-            mPostBodyChannel = channel;
+            //mPostBodyChannel = new UploadChannel();
             mPostBodySet = true;
         }
         mAppendChunkSemaphore = new Semaphore(0);
+        return new UploadChannel();
     }
 
     public WritableByteChannel getSink() {
         return mSink;
     }
 
     public void start() {
         try {
             synchronized (mLock) {
                 if (mCanceled) {
@@ skipping 16 matching lines @@
                     for (Entry<String, String> entry :
                             mAdditionalHeaders.entrySet()) {
                         nativeAddHeader(mUrlRequestPeer, entry.getKey(),
                                 entry.getValue());
                     }
                 }
 
                 nativeStart(mUrlRequestPeer);
             }
 
-            if (mPostBodyChannel != null) {
-                uploadFromChannel(mPostBodyChannel);
-            }
         } finally {
             if (mPostBodyChannel != null) {
                 try {
                     mPostBodyChannel.close();
                 } catch (IOException e) {
                     // Ignore
                 }
             }
         }
     }
 
-    /**
-     * 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.
-     */
-    private void uploadFromChannel(ReadableByteChannel channel) {
-        ByteBuffer buffer = ByteBuffer.allocateDirect(UPLOAD_BYTE_BUFFER_SIZE);
-
-        // The chromium API requires us to specify in advance if a chunk is the
-        // last one. This extra ByteBuffer is needed to peek ahead and check for
-        // the end of the channel.
-        ByteBuffer checkForEnd = ByteBuffer.allocate(1);
-
-        try {
-            boolean lastChunk;
-            do {
-                // First dump in the one byte we read to check for the end of
-                // the channel. (The first time through the loop the checkForEnd
-                // buffer will be empty).
-                checkForEnd.flip();
-                buffer.clear();
-                buffer.put(checkForEnd);
-                checkForEnd.clear();
-
-                channel.read(buffer);
-                lastChunk = channel.read(checkForEnd) <= 0;
-                buffer.flip();
-                nativeAppendChunk(mUrlRequestPeer, buffer, buffer.limit(),
-                        lastChunk);
-
-                if (lastChunk) {
-                    break;
-                }
-
-                // 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();
-        }
-    }
-
     public void cancel() {
         synchronized (mLock) {
             if (mCanceled) {
                 return;
             }
 
             mCanceled = true;
 
             if (!mRecycled) {
                 nativeCancel(mUrlRequestPeer);
@@ skipping 62 matching lines @@
 
     public String getContentType() {
         return mContentType;
     }
 
     public String getHeader(String name) {
         validateHeadersAvailable();
         return nativeGetHeader(mUrlRequestPeer, name);
     }
 
+    // All response headers.
+    public Map<String, List<String>> getAllHeaders() {
+        validateHeadersAvailable();
+        String[] headers = nativeGetAllHeaders(mUrlRequestPeer);
+        Map<String, List<String>> result = new HashMap<String, List<String>>();
+        for (int i = 0; i < headers.length / 2; ++i) {
+            String key = headers[2 * i];
+            String value = headers[2 * i + 1];
+            if (!result.containsKey(key)) {
+                result.put(key, new ArrayList<String>());
+            }
+            result.get(key).add(value);
+        }
+        return result;
+    }
+
+
     /**
      * 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.
@@ skipping 75 matching lines @@
         }
     }
 
 
     private void validateHeadersAvailable() {
         if (!mHeadersAvailable) {
             throw new IllegalStateException("Response headers not available");
         }
     }
 
+    /**
+     * Invokes {@link #nativeAppendChunk(long, ByteBuffer, int, boolean)} and
+     * waits for it to notify completion.
+     * @param chunk The data. It's position must be zero.
+     * @param isLastChunk Whether chunk is the last one.
+     */
+    void appendChunkBlocking(ByteBuffer chunk, boolean isLastChunk)
+            throws IOException {
+        if (chunk.position() != 0) {
+            throw new IllegalArgumentException("The position must be zero.");
+        }
+        synchronized (mLock) {
+            if (mUrlRequestPeer == 0) {
+                throw new IOException("Native peer destroyed.");
+            }
+            nativeAppendChunk(mUrlRequestPeer, chunk, chunk.limit(), false);
+            // Wait for the data to be actually consumed.
+            try {
+                mAppendChunkSemaphore.acquire();
+            } catch (InterruptedException e) {
+                // We were interrupted before the data was uploaded. Recovering
+                // from this state is complicated so we cancel the upload
+                // operation and fail.
+                Thread.currentThread().interrupt();
+
+                // TODO(miloslav): Not sure why do we set mSinkException here.
+                mSinkException = new IOException("Upload interrupted", e);
+                cancel();
+                throw mSinkException;
+            }
+        }
+    }
+
     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 16 matching lines @@
 
     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);
+
+    private native String[] nativeGetAllHeaders(long urlRequestPeer);
+
+
+    class UploadChannel implements WritableByteChannel {
+
+        private boolean mOpen = true;
+        // Native wants a direct buffer.
+        private final ByteBuffer mBuffer =
+                ByteBuffer.allocateDirect(UPLOAD_BYTE_BUFFER_SIZE);
+
+        @Override
+        public synchronized boolean isOpen() {
+            return mOpen;
+        }
+
+        @Override
+        public synchronized void close() throws IOException {
+            if (DBG) Log.d(TAG, "UploadChannel.close() url=" + getUrl());
+            if (!mOpen) {
+                return;
+            }
+
+            mOpen = false;
+            mBuffer.clear();
+
+            // NOOP If the native peer has been destroyed.
+            try {
+                if (DBG) Log.d(TAG, "UploadChannel.close(): final chunk.");
+                appendChunkBlocking(mBuffer, true);
+            } catch (IOException e) {
+                Log.w(TAG, "Ignoring exception during closing.", e);
+            }
+
+            if (DBG) Log.d(TAG, "UploadChannel.close() done.");
+        }
+
+        @Override
+        public synchronized int write(ByteBuffer sourceBuffer)
+                throws IOException {
+            if (DBG) Log.d(TAG, "UploadChannel.write("
+                    + sourceBuffer.remaining() + " bytes) url=" + getUrl());
+            int written = 0;
+            while (sourceBuffer.hasRemaining()) {
+                mBuffer.clear();
+                int oldLimit = sourceBuffer.limit();
+                if (sourceBuffer.remaining() > mBuffer.remaining()) {
+                    sourceBuffer.limit(sourceBuffer.position()
+                            + mBuffer.remaining());
+                }
+                mBuffer.put(sourceBuffer);
+                mBuffer.flip();
+                written += mBuffer.limit();
+                appendChunkBlocking(mBuffer, false);
+                sourceBuffer.limit(oldLimit);
+            }
+            if (DBG) Log.d(TAG, "UploadChannel.write() returning");
+            return written;
+        }
+
+    }
 }