Rename CronetUploadDataStreamAdapter to CronetUploadDataStream.

components/cronet/android/java/src/org/chromium/net/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;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 import org.chromium.base.NativeClassQualifiedName;
 
@@ skipping 34 matching lines @@
     // ByteBuffer created in the native code and passed to
     // UploadDataProvider for reading. It is only valid from the
     // call to mDataProvider.read until onError or onReadSucceeded.
     private ByteBuffer mByteBuffer = null;
 
     // Lock that protects all subsequent variables. The delegate has to be
     // protected to ensure safe shutdown, mReading and mRewinding are protected
     // to robustly detect getting read/rewind results more often than expected.
     private final Object mLock = new Object();
 
-    // Native adapter delegate object, owned by the CronetUploadDataStream.
-    // It's only deleted after the native UploadDataStream object is destroyed.
-    // All access to the delegate is synchronized, for safe usage and cleanup.
+    // Native delegate object, owned by the CronetUploadDataStream. It's only
+    // deleted after the native UploadDataStream object is destroyed. All access
+    // to the delegate is synchronized, for safe usage and cleanup.
     private long mUploadDataStreamDelegate = 0;
 
     private boolean mReading = false;
     private boolean mRewinding = false;
     private boolean mDestroyDelegatePostponed = false;
 
     /**
      * Constructs a CronetUploadDataStream.
      * @param dataProvider the UploadDataProvider to read data from.
      * @param executor the Executor to execute UploadDataProvider tasks.
@@ skipping 40 matching lines @@
                     mDataProvider.rewind(CronetUploadDataStream.this);
                 } catch (Exception exception) {
                     onError(exception);
                 }
             }
         };
         mExecutor.execute(task);
     }
 
     /**
-     * Called by native code to destroy the native adapter delegate, when the
-     * adapter is destroyed.
+     * Called when the native UploadDataStream is destroyed.  At this point,
+     * the native delegate needs to be destroyed, but only after any pending
+     * read operation completes, as the delegate owns the read buffer.
      */
     @SuppressWarnings("unused")
     @CalledByNative
-    void onAdapterDestroyed() {
+    void onUploadDataStreamDestroyed() {
         Runnable task = new Runnable() {
             @Override
             public void run() {
                 destroyDelegate();
             }
         };
 
         mExecutor.execute(task);
     }
 
     /**
      * Helper method called when an exception occurred. This method resets
      * states and propagates the error to the request.
      */
     private void onError(Exception exception) {
         synchronized (mLock) {
             if (!mReading && !mRewinding) {
                 throw new IllegalStateException(
                         "There is no read or rewind in progress.");
             }
             mReading = false;
             mRewinding = false;
             mByteBuffer = null;
             destroyDelegateIfPostponed();
         }
 
         // Just fail the request - simpler to fail directly, and
         // UploadDataStream only supports failing during initialization, not
-        // while reading. This should be safe, even if we deleted the adapter,
-        // because in that case, the request has already been cancelled.
+        // while reading. The request is smart enough to handle the case where
+        // it was already cancelled by the embedder.
         mRequest.onUploadException(exception);
     }
 
     @Override
     public void onReadSucceeded(boolean lastChunk) {
         synchronized (mLock) {
             if (!mReading) {
                 throw new IllegalStateException("Non-existent read succeeded.");
             }
             if (lastChunk && mLength >= 0) {
@@ skipping 95 matching lines @@
      * an interface with just this method, to minimize CronetURLRequest's
      * dependencies on each upload stream type.
      */
     void attachToRequest(CronetUrlRequest request, long requestAdapter) {
         mRequest = request;
         mUploadDataStreamDelegate =
                 nativeAttachUploadDataToRequest(requestAdapter, mLength);
     }
 
     /**
-     * Creates a native UploadDataStreamDelegate and UploadDataStreamAdapter
-     * for testing.
-     * @return the address of the native CronetUploadDataStreamAdapter object.
+     * Creates a native CronetUploadDataStreamDelegate and
+     * CronetUploadDataStream for testing.
+     * @return the address of the native CronetUploadDataStream object.
      */
-    public long createAdapterForTesting() {
+    public long createUploadDataStreamForTesting() {
         mUploadDataStreamDelegate = nativeCreateDelegateForTesting();
-        return nativeCreateAdapterForTesting(mLength, mUploadDataStreamDelegate);
+        return nativeCreateUploadDataStreamForTesting(mLength,
+                mUploadDataStreamDelegate);
     }
 
-    // Native methods are implemented in upload_data_stream_adapter.cc.
+    // Native methods are implemented in upload_data_stream.cc.
 
     private native long nativeAttachUploadDataToRequest(long urlRequestAdapter,
             long length);
 
     private native long nativeCreateDelegateForTesting();
 
-    private native long nativeCreateAdapterForTesting(long length,
+    private native long nativeCreateUploadDataStreamForTesting(long length,
             long delegate);
 
     @NativeClassQualifiedName("CronetUploadDataStreamDelegate")
     private native void nativeOnReadSucceeded(long nativePtr,
             int bytesRead, boolean finalChunk);
 
     @NativeClassQualifiedName("CronetUploadDataStreamDelegate")
     private native void nativeOnRewindSucceeded(long nativePtr);
 
     private static native void nativeDestroyDelegate(
             long uploadDataStreamDelegate);
 }