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

components/cronet/android/java/src/org/chromium/net/impl/CronetUploadDataStream.java

 // Copyright 2015 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.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.annotations.NativeClassQualifiedName;
+import org.chromium.net.UploadDataProvider;
+import org.chromium.net.UploadDataSink;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.concurrent.Executor;
 
 import javax.annotation.concurrent.GuardedBy;
 
 /**
  * CronetUploadDataStream handles communication between an upload body
  * encapsulated in the embedder's {@link UploadDataSink} and a C++
  * UploadDataStreamAdapter, which it owns. It's attached to a {@link
  * CronetUrlRequest}'s during the construction of request's native C++ objects
  * on the network thread, though it's created on one of the embedder's threads.
  * It is called by the UploadDataStreamAdapter on the network thread, but calls
  * into the UploadDataSink and the UploadDataStreamAdapter on the Executor
  * passed into its constructor.
  */
 @JNINamespace("cronet")
-final class CronetUploadDataStream implements UploadDataSink {
+@VisibleForTesting
+public final class CronetUploadDataStream implements UploadDataSink {
     private static final String TAG = "CronetUploadDataStream";
     // These are never changed, once a request starts.
     private final Executor mExecutor;
     private final UploadDataProvider mDataProvider;
     private long mLength;
     private long mRemainingLength;
     private CronetUrlRequest mRequest;
 
     // Reusable read task, to reduce redundant memory allocation.
     private final Runnable mReadTask = new Runnable() {
         @Override
         public void run() {
             synchronized (mLock) {
                 if (mUploadDataStreamAdapter == 0) {
                     return;
                 }
                 checkState(UserCallback.NOT_IN_CALLBACK);
                 if (mByteBuffer == null) {
-                    throw new IllegalStateException(
-                            "Unexpected readData call. Buffer is null");
+                    throw new IllegalStateException("Unexpected readData call. Buffer is null");
                 }
                 mInWhichUserCallback = UserCallback.READ;
             }
             try {
                 mDataProvider.read(CronetUploadDataStream.this, mByteBuffer);
             } catch (Exception exception) {
                 onError(exception);
             }
         }
     };
@@ skipping 114 matching lines @@
         // while reading. The request is smart enough to handle the case where
         // it was already canceled by the embedder.
         mRequest.onUploadException(exception);
     }
 
     @Override
     public void onReadSucceeded(boolean lastChunk) {
         synchronized (mLock) {
             checkState(UserCallback.READ);
             if (lastChunk && mLength >= 0) {
-                throw new IllegalArgumentException(
-                        "Non-chunked upload can't have last chunk");
+                throw new IllegalArgumentException("Non-chunked upload can't have last chunk");
             }
             int bytesRead = mByteBuffer.position();
             mRemainingLength -= bytesRead;
             if (mRemainingLength < 0 && mLength >= 0) {
                 throw new IllegalArgumentException(
                         String.format("Read upload data length %d exceeds expected length %d",
                                 mLength - mRemainingLength, mLength));
             }
             mByteBuffer = null;
             mInWhichUserCallback = UserCallback.NOT_IN_CALLBACK;
 
             destroyAdapterIfPostponed();
             // Request may been canceled already.
             if (mUploadDataStreamAdapter == 0) {
                 return;
             }
-            nativeOnReadSucceeded(mUploadDataStreamAdapter, bytesRead,
-                    lastChunk);
+            nativeOnReadSucceeded(mUploadDataStreamAdapter, bytesRead, lastChunk);
         }
     }
 
     @Override
     public void onReadError(Exception exception) {
         synchronized (mLock) {
             checkState(UserCallback.READ);
             onError(exception);
         }
     }
@@ skipping 115 matching lines @@
             mUploadDataStreamAdapter = nativeAttachUploadDataToRequest(requestAdapter, mLength);
         }
     }
 
     /**
      * Creates a native CronetUploadDataStreamAdapter and
      * CronetUploadDataStream for testing.
      * @return the address of the native CronetUploadDataStream object.
      */
     @VisibleForTesting
-    long createUploadDataStreamForTesting() throws IOException {
+    public long createUploadDataStreamForTesting() throws IOException {
         synchronized (mLock) {
             mUploadDataStreamAdapter = nativeCreateAdapterForTesting();
             mLength = mDataProvider.getLength();
             mRemainingLength = mLength;
             return nativeCreateUploadDataStreamForTesting(mLength, mUploadDataStreamAdapter);
         }
     }
 
     @VisibleForTesting
     void setOnDestroyedCallbackForTesting(Runnable onDestroyedCallbackForTesting) {
         mOnDestroyedCallbackForTesting = onDestroyedCallbackForTesting;
     }
 
     // Native methods are implemented in upload_data_stream_adapter.cc.
 
-    private native long nativeAttachUploadDataToRequest(long urlRequestAdapter,
-            long length);
+    private native long nativeAttachUploadDataToRequest(long urlRequestAdapter, long length);
 
     private native long nativeCreateAdapterForTesting();
 
-    private native long nativeCreateUploadDataStreamForTesting(long length,
-            long adapter);
+    private native long nativeCreateUploadDataStreamForTesting(long length, long adapter);
 
     @NativeClassQualifiedName("CronetUploadDataStreamAdapter")
-    private native void nativeOnReadSucceeded(long nativePtr,
-            int bytesRead, boolean finalChunk);
+    private native void nativeOnReadSucceeded(long nativePtr, int bytesRead, boolean finalChunk);
 
     @NativeClassQualifiedName("CronetUploadDataStreamAdapter")
     private native void nativeOnRewindSucceeded(long nativePtr);
 
     @NativeClassQualifiedName("CronetUploadDataStreamAdapter")
     private static native void nativeDestroy(long nativePtr);
 }