[Cronet] Separate Cronet implementation and API by package name.

components/cronet/android/java/src/org/chromium/net/impl/ChromiumUrlRequest.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;
+package org.chromium.net.impl;
 
 import android.util.Log;
 
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.annotations.SuppressFBWarnings;
+import org.chromium.net.ChromiumUrlRequestError;
+import org.chromium.net.ChromiumUrlRequestPriority;
+import org.chromium.net.ChunkedWritableByteChannel;
+import org.chromium.net.HttpUrlRequest;
+import org.chromium.net.HttpUrlRequestListener;
+import org.chromium.net.ResponseTooLargeException;
 
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.SocketTimeoutException;
 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;
@@ skipping 56 matching lines @@
 
     // Native error code. Default to no error. Populated in onRequestComplete().
     private int mErrorCode = ChromiumUrlRequestError.SUCCESS;
 
     // Native error string. Default to null. Populated in onRequestComplete().
     private String mErrorString;
 
     // Protects access of mUrlRequestAdapter, mStarted, mCanceled, and mFinished.
     private final Object mLock = new Object();
 
-    public ChromiumUrlRequest(ChromiumUrlRequestContext requestContext,
-            String url, int priority, Map<String, String> headers,
-            HttpUrlRequestListener listener) {
-        this(requestContext, url, priority, headers,
-                new ChunkedWritableByteChannel(), listener);
+    public ChromiumUrlRequest(ChromiumUrlRequestContext requestContext, String url, int priority,
+            Map<String, String> headers, HttpUrlRequestListener listener) {
+        this(requestContext, url, priority, headers, new ChunkedWritableByteChannel(), listener);
         mBufferFullResponse = true;
     }
 
     /**
      * Constructor.
      *
      * @param requestContext The context.
      * @param url The URL.
      * @param priority Request priority, e.g. {@link #REQUEST_PRIORITY_MEDIUM}.
      * @param headers HTTP headers.
      * @param sink The output channel into which downloaded content will be
      *            written.
      */
-    public ChromiumUrlRequest(ChromiumUrlRequestContext requestContext,
-            String url, int priority, Map<String, String> headers,
-            WritableByteChannel sink, HttpUrlRequestListener listener) {
+    public ChromiumUrlRequest(ChromiumUrlRequestContext requestContext, String url, int priority,
+            Map<String, String> headers, WritableByteChannel sink,
+            HttpUrlRequestListener listener) {
         if (requestContext == null) {
             throw new NullPointerException("Context is required");
         }
         if (url == null) {
             throw new NullPointerException("URL is required");
         }
         mRequestContext = requestContext;
         mUrl = url;
         mPriority = convertRequestPriority(priority);
         mHeaders = headers;
@@ skipping 73 matching lines @@
                 try {
                     host = new URL(mUrl).getHost();
                 } catch (MalformedURLException e) {
                     host = mUrl;
                 }
                 return new UnknownHostException("Unknown host: " + host);
             case ChromiumUrlRequestError.TOO_MANY_REDIRECTS:
                 return new IOException("Request failed because there were too "
                         + "many redirects or redirects have been disabled");
             default:
-                throw new IllegalStateException(
-                        "Unrecognized error code: " + mErrorCode);
+                throw new IllegalStateException("Unrecognized error code: " + mErrorCode);
         }
     }
 
     @Override
     public ByteBuffer getByteBuffer() {
         return ((ChunkedWritableByteChannel) getSink()).getByteBuffer();
     }
 
     @Override
     public byte[] getResponseAsBytes() {
@@ skipping 36 matching lines @@
     /**
      * Sets a readable byte channel to upload as part of a POST or PUT request.
      *
      * @param contentType MIME type of the upload content or null if this is not
      *            an upload request.
      * @param channel The channel to read to read upload data from if this is an
      *            upload request.
      * @param contentLength The length of data to upload.
      */
     @Override
-    public void setUploadChannel(String contentType,
-            ReadableByteChannel channel, long contentLength) {
+    public void setUploadChannel(
+            String contentType, ReadableByteChannel channel, long contentLength) {
         synchronized (mLock) {
             validateNotStarted();
             validateContentType(contentType);
             mUploadContentType = contentType;
             mUploadChannel = channel;
             mUploadContentLength = contentLength;
             mUploadData = null;
             mChunkedUpload = false;
         }
     }
@@ skipping 18 matching lines @@
 
     /**
      * Uploads a new chunk. Must have called {@link #setChunkedUpload(String)}
      * and {@link #start()}.
      *
      * @param chunk The data, which will not be modified. Its current position.
      *            must be zero. The last chunk can be empty, but all other
      *            chunks must be non-empty.
      * @param isLastChunk Whether this chunk is the last one.
      */
-    public void appendChunk(ByteBuffer chunk, boolean isLastChunk)
-            throws IOException {
+    public void appendChunk(ByteBuffer chunk, boolean isLastChunk) throws IOException {
         if (!isLastChunk && !chunk.hasRemaining()) {
-            throw new IllegalArgumentException(
-                    "Attempted to write empty buffer.");
+            throw new IllegalArgumentException("Attempted to write empty buffer.");
         }
         if (chunk.position() != 0) {
             throw new IllegalArgumentException("The position must be zero.");
         }
         synchronized (mLock) {
             if (!mStarted) {
                 throw new IllegalStateException("Request not yet started.");
             }
             if (!mChunkedUpload) {
-                throw new IllegalStateException(
-                        "Request not set for chunked uploadind.");
+                throw new IllegalStateException("Request not set for chunked uploadind.");
             }
             if (mUrlRequestAdapter == 0) {
                 throw new IOException("Native peer destroyed.");
             }
-            nativeAppendChunk(mUrlRequestAdapter, chunk, chunk.limit(),
-                    isLastChunk);
+            nativeAppendChunk(mUrlRequestAdapter, chunk, chunk.limit(), isLastChunk);
         }
     }
 
     @Override
     public void setHttpMethod(String method) {
         validateNotStarted();
         mMethod = method;
     }
 
     @Override
@@ skipping 17 matching lines @@
                 return;
             }
 
             validateNotStarted();
             validateNativeAdapterNotDestroyed();
 
             mStarted = true;
 
             if (mHeaders != null && !mHeaders.isEmpty()) {
                 for (Entry<String, String> entry : mHeaders.entrySet()) {
-                    nativeAddHeader(mUrlRequestAdapter, entry.getKey(),
-                            entry.getValue());
+                    nativeAddHeader(mUrlRequestAdapter, entry.getKey(), entry.getValue());
                 }
             }
 
             if (mAdditionalHeaders != null) {
-                for (Entry<String, String> entry :
-                        mAdditionalHeaders.entrySet()) {
-                    nativeAddHeader(mUrlRequestAdapter, entry.getKey(),
-                            entry.getValue());
+                for (Entry<String, String> entry : mAdditionalHeaders.entrySet()) {
+                    nativeAddHeader(mUrlRequestAdapter, entry.getKey(), entry.getValue());
                 }
             }
 
             if (mUploadData != null && mUploadData.length > 0) {
-                nativeSetUploadData(mUrlRequestAdapter, mUploadContentType,
-                                    mUploadData);
+                nativeSetUploadData(mUrlRequestAdapter, mUploadContentType, mUploadData);
             } else if (mUploadChannel != null) {
-                nativeSetUploadChannel(mUrlRequestAdapter, mUploadContentType,
-                                       mUploadContentLength);
+                nativeSetUploadChannel(
+                        mUrlRequestAdapter, mUploadContentType, mUploadContentLength);
             } else if (mChunkedUpload) {
-                nativeEnableChunkedUpload(mUrlRequestAdapter,
-                                          mUploadContentType);
+                nativeEnableChunkedUpload(mUrlRequestAdapter, mUploadContentType);
             }
 
             // Note:  The above functions to set the upload body also set the
             // method to POST, behind the scenes, so if mMethod is null but
             // there's an upload body, the method will default to POST.
             if (mMethod != null) {
                 nativeSetMethod(mUrlRequestAdapter, mMethod);
             }
 
             nativeStart(mUrlRequestAdapter);
@@ skipping 135 matching lines @@
         }
     }
 
     // Private methods called by native library.
 
     /**
      * If @CalledByNative method throws an exception, request gets canceled
      * and exception could be retrieved from request using getException().
      */
     private void onCalledByNativeException(Exception e) {
-        mSinkException = new IOException(
-                "CalledByNative method has thrown an exception", e);
-        Log.e(ChromiumUrlRequestContext.LOG_TAG,
-                "Exception in CalledByNative method", e);
+        mSinkException = new IOException("CalledByNative method has thrown an exception", e);
+        Log.e(ChromiumUrlRequestContext.LOG_TAG, "Exception in CalledByNative method", e);
         try {
             cancel();
         } catch (Exception cancel_exception) {
-            Log.e(ChromiumUrlRequestContext.LOG_TAG,
-                    "Exception trying to cancel request", cancel_exception);
+            Log.e(ChromiumUrlRequestContext.LOG_TAG, "Exception trying to cancel request",
+                    cancel_exception);
         }
     }
 
     /**
      * A callback invoked when the first chunk of the response has arrived.
      */
     @CalledByNative
     private void onResponseStarted() {
         try {
             mHttpStatusCode = nativeGetHttpStatusCode(mUrlRequestAdapter);
             mHttpStatusText = nativeGetHttpStatusText(mUrlRequestAdapter);
             mContentType = nativeGetContentType(mUrlRequestAdapter);
             mContentLength = nativeGetContentLength(mUrlRequestAdapter);
             mHeadersAvailable = true;
 
-            if (mContentLengthLimit > 0
-                    && mContentLength > mContentLengthLimit
+            if (mContentLengthLimit > 0 && mContentLength > mContentLengthLimit
                     && mCancelIfContentLengthOverLimit) {
                 onContentLengthOverLimit();
                 return;
             }
 
-            if (mBufferFullResponse && mContentLength != -1
-                    && !mContentLengthOverLimit) {
-                ((ChunkedWritableByteChannel) getSink()).setCapacity(
-                        (int) mContentLength);
+            if (mBufferFullResponse && mContentLength != -1 && !mContentLengthOverLimit) {
+                ((ChunkedWritableByteChannel) getSink()).setCapacity((int) mContentLength);
             }
 
             if (mOffset != 0) {
                 // The server may ignore the request for a byte range, in which
                 // case status code will be 200, instead of 206. Note that we
                 // cannot call getHttpStatusCode as it rewrites 206 into 200.
                 if (mHttpStatusCode == 200) {
                     // TODO(mef): Revisit this logic.
                     if (mContentLength != -1) {
                         mContentLength -= mOffset;
@@ skipping 86 matching lines @@
         } catch (Exception e) {
             mSinkException = new IOException("Exception in finish", e);
         }
     }
 
     /**
      * Appends header |name| with value |value| to |headersMap|.
      */
     @SuppressWarnings("unused")
     @CalledByNative
-    private void onAppendResponseHeader(ResponseHeadersMap headersMap,
-            String name, String value) {
+    private void onAppendResponseHeader(ResponseHeadersMap headersMap, String name, String value) {
         try {
             if (!headersMap.containsKey(name)) {
                 headersMap.put(name, new ArrayList<String>());
             }
             headersMap.get(name).add(value);
         } catch (Exception e) {
             onCalledByNativeException(e);
         }
     }
 
@@ skipping 18 matching lines @@
             onCalledByNativeException(e);
         }
         return -1;
     }
 
     // Native methods are implemented in chromium_url_request.cc.
 
     private native long nativeCreateRequestAdapter(
             long urlRequestContextAdapter, String url, int priority);
 
-    private native void nativeAddHeader(long urlRequestAdapter, String name,
-            String value);
+    private native void nativeAddHeader(long urlRequestAdapter, String name, String value);
 
     private native void nativeSetMethod(long urlRequestAdapter, String method);
 
-    private native void nativeSetUploadData(long urlRequestAdapter,
-            String contentType, byte[] content);
+    private native void nativeSetUploadData(
+            long urlRequestAdapter, String contentType, byte[] content);
 
-    private native void nativeSetUploadChannel(long urlRequestAdapter,
-            String contentType, long contentLength);
+    private native void nativeSetUploadChannel(
+            long urlRequestAdapter, String contentType, long contentLength);
 
-    private native void nativeEnableChunkedUpload(long urlRequestAdapter,
-            String contentType);
+    private native void nativeEnableChunkedUpload(long urlRequestAdapter, String contentType);
 
     private native void nativeDisableRedirects(long urlRequestAdapter);
 
-    private native void nativeAppendChunk(long urlRequestAdapter,
-            ByteBuffer chunk, int chunkSize, boolean isLastChunk);
+    private native void nativeAppendChunk(
+            long urlRequestAdapter, ByteBuffer chunk, int chunkSize, boolean isLastChunk);
 
     private native void nativeStart(long urlRequestAdapter);
 
     private native void nativeCancel(long urlRequestAdapter);
 
     private native void nativeDestroyRequestAdapter(long urlRequestAdapter);
 
     private native int nativeGetErrorCode(long urlRequestAdapter);
 
     private native int nativeGetHttpStatusCode(long urlRequestAdapter);
 
     private native String nativeGetHttpStatusText(long urlRequestAdapter);
 
     private native String nativeGetErrorString(long urlRequestAdapter);
 
     private native String nativeGetContentType(long urlRequestAdapter);
 
     private native long nativeGetContentLength(long urlRequestAdapter);
 
     private native String nativeGetHeader(long urlRequestAdapter, String name);
 
-    private native void nativeGetAllHeaders(long urlRequestAdapter,
-            ResponseHeadersMap headers);
+    private native void nativeGetAllHeaders(long urlRequestAdapter, ResponseHeadersMap headers);
 
     private native String nativeGetNegotiatedProtocol(long urlRequestAdapter);
 
     private native boolean nativeGetWasCached(long urlRequestAdapter);
 
     // Explicit class to work around JNI-generator generics confusion.
-    private static class ResponseHeadersMap extends
-            HashMap<String, List<String>> {
-    }
+    private static class ResponseHeadersMap extends HashMap<String, List<String>> {}
 }