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

components/cronet/android/java/src/org/chromium/net/impl/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;
+package org.chromium.net.impl;
 
 import android.os.SystemClock;
 import android.support.annotation.Nullable;
 import android.util.Log;
 
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNIAdditionalImport;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.annotations.NativeClassQualifiedName;
 import org.chromium.net.CronetEngine.UrlRequestInfo;
 import org.chromium.net.CronetEngine.UrlRequestMetrics;
+import org.chromium.net.Preconditions;
+import org.chromium.net.QuicException;
+import org.chromium.net.RequestPriority;
+import org.chromium.net.UploadDataProvider;
+import org.chromium.net.UrlRequest;
+import org.chromium.net.UrlRequestException;
+import org.chromium.net.UrlResponseInfo;
 
 import java.nio.ByteBuffer;
 import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Executor;
 import java.util.concurrent.RejectedExecutionException;
 
 import javax.annotation.concurrent.GuardedBy;
 
 /**
  * UrlRequest using Chromium HTTP stack implementation. Could be accessed from
  * any thread on Executor. Cancel can be called from any thread.
  * All @CallByNative methods are called on native network thread
  * and post tasks with listener calls onto Executor. Upon return from listener
  * callback native request adapter is called on executive thread and posts
  * native tasks to native network thread. Because Cancel could be called from
  * any thread it is protected by mUrlRequestAdapterLock.
  */
 @JNINamespace("cronet")
 // Qualifies UrlRequest.StatusListener which is used in onStatus, a JNI method.
 @JNIAdditionalImport(UrlRequest.class)
-final class CronetUrlRequest implements UrlRequest {
+@VisibleForTesting
+public final class CronetUrlRequest implements UrlRequest {
     private static final UrlRequestMetrics EMPTY_METRICS =
             new UrlRequestMetrics(null, null, null, null);
 
     /* Native adapter object, owned by UrlRequest. */
     @GuardedBy("mUrlRequestAdapterLock")
     private long mUrlRequestAdapter;
 
     @GuardedBy("mUrlRequestAdapterLock")
     private boolean mStarted = false;
     @GuardedBy("mUrlRequestAdapterLock")
@@ skipping 278 matching lines @@
         };
         postTaskToExecutor(task);
     }
 
     @VisibleForTesting
     public void setOnDestroyedCallbackForTesting(Runnable onDestroyedCallbackForTesting) {
         mOnDestroyedCallbackForTesting = onDestroyedCallbackForTesting;
     }
 
     @VisibleForTesting
-    void setOnDestroyedUploadCallbackForTesting(Runnable onDestroyedUploadCallbackForTesting) {
+    public void setOnDestroyedUploadCallbackForTesting(
+            Runnable onDestroyedUploadCallbackForTesting) {
         mUploadDataStream.setOnDestroyedCallbackForTesting(onDestroyedUploadCallbackForTesting);
     }
 
     @VisibleForTesting
-    long getUrlRequestAdapterForTesting() {
+    public long getUrlRequestAdapterForTesting() {
         synchronized (mUrlRequestAdapterLock) {
             return mUrlRequestAdapter;
         }
     }
 
     /**
      * Posts task to application Executor. Used for Listener callbacks
      * and other tasks that should not be executed on network thread.
      */
     private void postTaskToExecutor(Runnable task) {
         try {
             mExecutor.execute(task);
         } catch (RejectedExecutionException failException) {
-            Log.e(CronetUrlRequestContext.LOG_TAG,
-                    "Exception posting task to executor", failException);
+            Log.e(CronetUrlRequestContext.LOG_TAG, "Exception posting task to executor",
+                    failException);
             // If posting a task throws an exception, then there is no choice
             // but to destroy the request without invoking the callback.
             destroyRequestAdapter(false);
         }
     }
 
     private static int convertRequestPriority(int priority) {
         switch (priority) {
             case Builder.REQUEST_PRIORITY_IDLE:
                 return RequestPriority.IDLE;
@@ skipping 49 matching lines @@
     }
 
     /**
      * If callback method throws an exception, request gets canceled
      * and exception is reported via onFailed listener callback.
      * Only called on the Executor.
      */
     private void onCallbackException(Exception e) {
         UrlRequestException requestError =
                 new UrlRequestException("Exception received from UrlRequest.Callback", e);
-        Log.e(CronetUrlRequestContext.LOG_TAG,
-                "Exception in CalledByNative method", e);
+        Log.e(CronetUrlRequestContext.LOG_TAG, "Exception in CalledByNative method", e);
         // Do not call into listener if request is finished.
         synchronized (mUrlRequestAdapterLock) {
             if (isDoneLocked()) {
                 return;
             }
             destroyRequestAdapter(false);
         }
         try {
             mCallback.onFailed(this, mResponseInfo, requestError);
         } catch (Exception failException) {
-            Log.e(CronetUrlRequestContext.LOG_TAG,
-                    "Exception notifying of failed request", failException);
+            Log.e(CronetUrlRequestContext.LOG_TAG, "Exception notifying of failed request",
+                    failException);
         }
     }
 
     /**
      * Called when UploadDataProvider encounters an error.
      */
     void onUploadException(Throwable e) {
         UrlRequestException uploadError =
                 new UrlRequestException("Exception received from UploadDataProvider", e);
         Log.e(CronetUrlRequestContext.LOG_TAG, "Exception in upload method", e);
         failWithException(uploadError);
     }
 
     /**
      * Fails the request with an exception. Can be called on any thread.
      */
     private void failWithException(final UrlRequestException exception) {
         Runnable task = new Runnable() {
             @Override
             public void run() {
                 synchronized (mUrlRequestAdapterLock) {
                     if (isDoneLocked()) {
                         return;
                     }
                     destroyRequestAdapter(false);
                 }
                 try {
                     mCallback.onFailed(CronetUrlRequest.this, mResponseInfo, exception);
                 } catch (Exception e) {
-                    Log.e(CronetUrlRequestContext.LOG_TAG,
-                            "Exception in onError method", e);
+                    Log.e(CronetUrlRequestContext.LOG_TAG, "Exception in onError method", e);
                 }
             }
         };
         postTaskToExecutor(task);
     }
 
     ////////////////////////////////////////////////
     // Private methods called by the native code.
     // Always called on network thread.
     ////////////////////////////////////////////////
@@ skipping 93 matching lines @@
      *        read(). Used as a minimal check that the buffer hasn't been
      *        modified while reading from the network.
      * @param receivedBytesCount number of bytes received.
      */
     @SuppressWarnings("unused")
     @CalledByNative
     private void onReadCompleted(final ByteBuffer byteBuffer, int bytesRead, int initialPosition,
             int initialLimit, long receivedBytesCount) {
         mResponseInfo.setReceivedBytesCount(mReceivedBytesCountFromRedirects + receivedBytesCount);
         if (byteBuffer.position() != initialPosition || byteBuffer.limit() != initialLimit) {
-            failWithException(new UrlRequestException(
-                    "ByteBuffer modified externally during read", null));
+            failWithException(
+                    new UrlRequestException("ByteBuffer modified externally during read", null));
             return;
         }
         if (mOnReadCompletedTask == null) {
             mOnReadCompletedTask = new OnReadCompletedRunnable();
         }
         byteBuffer.position(initialPosition + bytesRead);
         mOnReadCompletedTask.mByteBuffer = byteBuffer;
         postTaskToExecutor(mOnReadCompletedTask);
     }
 
@@ skipping 14 matching lines @@
                     if (isDoneLocked()) {
                         return;
                     }
                     // Destroy adapter first, so request context could be shut
                     // down from the listener.
                     destroyRequestAdapter(false);
                 }
                 try {
                     mCallback.onSucceeded(CronetUrlRequest.this, mResponseInfo);
                 } catch (Exception e) {
-                    Log.e(CronetUrlRequestContext.LOG_TAG,
-                            "Exception in onComplete method", e);
+                    Log.e(CronetUrlRequestContext.LOG_TAG, "Exception in onComplete method", e);
                 }
             }
         };
         postTaskToExecutor(task);
     }
 
     /**
      * Called when error has occured, no callbacks will be called afterwards.
      *
      * @param errorCode error code from {@link UrlRequestException.ERROR_LISTENER_EXCEPTION_THROWN
@@ skipping 55 matching lines @@
     }
 
     UrlRequestInfo getRequestInfo() {
         return new UrlRequestInfo(mInitialUrl, mRequestAnnotations,
                 (mRequestMetricsAccumulator != null ? mRequestMetricsAccumulator.getRequestMetrics()
                                                     : EMPTY_METRICS),
                 mResponseInfo);
     }
 
     private final class UrlRequestMetricsAccumulator {
-        @Nullable private Long mRequestStartTime;
-        @Nullable private Long mTtfbMs;
-        @Nullable private Long mTotalTimeMs;
+        @Nullable
+        private Long mRequestStartTime;
+        @Nullable
+        private Long mTtfbMs;
+        @Nullable
+        private Long mTotalTimeMs;
 
         private UrlRequestMetrics getRequestMetrics() {
             return new UrlRequestMetrics(mTtfbMs, mTotalTimeMs,
                     null, // TODO(klm): Compute sentBytesCount.
                     (mResponseInfo != null ? mResponseInfo.getReceivedBytesCount() : 0));
         }
 
         private void onRequestStarted() {
             if (mRequestStartTime != null) {
                 throw new IllegalStateException("onRequestStarted called repeatedly");
@@ skipping 25 matching lines @@
     @NativeClassQualifiedName("CronetURLRequestAdapter")
     private native boolean nativeAddRequestHeader(long nativePtr, String name, String value);
 
     @NativeClassQualifiedName("CronetURLRequestAdapter")
     private native void nativeStart(long nativePtr);
 
     @NativeClassQualifiedName("CronetURLRequestAdapter")
     private native void nativeFollowDeferredRedirect(long nativePtr);
 
     @NativeClassQualifiedName("CronetURLRequestAdapter")
-    private native boolean nativeReadData(long nativePtr, ByteBuffer byteBuffer,
-            int position, int capacity);
+    private native boolean nativeReadData(
+            long nativePtr, ByteBuffer byteBuffer, int position, int capacity);
 
     @NativeClassQualifiedName("CronetURLRequestAdapter")
     private native void nativeDestroy(long nativePtr, boolean sendOnCanceled);
 
     @NativeClassQualifiedName("CronetURLRequestAdapter")
     private native void nativeGetStatus(long nativePtr, UrlRequest.StatusListener listener);
 }