[Cronet] Upload support for async APIs

components/cronet/android/test/src/org/chromium/net/UploadDataStreamHandler.java

Index: components/cronet/android/test/src/org/chromium/net/UploadDataStreamHandler.java
diff --git a/components/cronet/android/test/src/org/chromium/net/UploadDataStreamHandler.java b/components/cronet/android/test/src/org/chromium/net/UploadDataStreamHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..edecef43e6c5bc72dce38696207dfa5e8eb4db49
--- /dev/null
+++ b/components/cronet/android/test/src/org/chromium/net/UploadDataStreamHandler.java
@@ -0,0 +1,170 @@
+// 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 android.os.ConditionVariable;
+
+import junit.framework.Assert;
+
+import org.chromium.base.CalledByNative;
+import org.chromium.base.JNINamespace;
+import org.chromium.base.NativeClassQualifiedName;
+
+/**
+ * A wrapper class on top of the native UploadDataStream. This class is used in
+ * tests to drive the native UploadDataStream directly.
+ */
+@JNINamespace("cronet")
+public final class UploadDataStreamHandler {

[mmenke, 2015/02/18 17:08:41]

optional:  Maybe TestUploadDataStreamHandler?  Think making class names clearer
that they're only for tests makes reading the code that actually uses them
easier.

[xunjieli, 2015/02/19 14:59:11]

Done. Good idea!

+    private long mUploadDataStreamHandler;
+    private ConditionVariable mWaitInitComplete;
+    private ConditionVariable mWaitInitCalled;
+    private ConditionVariable mWaitReadComplete;
+    private ConditionVariable mWaitResetComplete;
+    // Waits for checkIfInitCallbackInvoked() returns result asynchronously.
+    private ConditionVariable mWaitCheckInitCallback;
+    // Waits for checkIfReadCallbackInvoked() returns result asynchronously.
+    private ConditionVariable mWaitCheckReadCallback;

[mmenke, 2015/02/18 17:08:41]

optional:  Suggest removing the "Callback" from these two variable names -
"callback" is often used, Chrome side, for the methods themselves that are
called back, so it's easy to misinterpret those names.

[xunjieli, 2015/02/19 14:59:11]

Done.

+    // If true, init completes synchronously.
+    private boolean mInitCompletedSynchronously = false;
+    private String mData;
+
+    public UploadDataStreamHandler(final long adapter) {
+        mWaitReadComplete = new ConditionVariable();
+        mWaitInitComplete = new ConditionVariable();
+        mWaitInitCalled = new ConditionVariable();
+        mWaitResetComplete = new ConditionVariable();
+        mWaitCheckInitCallback = new ConditionVariable();
+        mWaitCheckReadCallback = new ConditionVariable();
+        mData = "";

[mmenke, 2015/02/18 17:08:41]

Should probably inline all these initializations above - my feeling is should
either do it wherever possible, or not at all, and we seem to be going the
former route in Cronet.

[xunjieli, 2015/02/19 14:59:11]

Done. 

+        mUploadDataStreamHandler = nativeCreateUploadDataStreamHandler(adapter);
+    }
+
+    public void destroyNativeObjects() {
+        nativeDestroy(mUploadDataStreamHandler);
+        mUploadDataStreamHandler = 0;
+    }
+
+    /**
+     * Init and returns whether init completes synchronously.
+     */
+    public boolean init() {
+        mWaitInitCalled.close();
+        mData = "";
+        nativeInit(mUploadDataStreamHandler);
+        mWaitInitCalled.block();
+        return mInitCompletedSynchronously;
+    }
+
+    public void read() {
+        nativeRead(mUploadDataStreamHandler);
+    }
+
+    public void reset() {
+        mWaitResetComplete.close();
+        mData = "";
+        nativeReset(mUploadDataStreamHandler);
+        mWaitResetComplete.block();
+    }
+
+    public void checkInitCallbackNotInvoked() {
+        mWaitCheckInitCallback.close();
+        nativeCheckInitCallbackNotInvoked(mUploadDataStreamHandler);
+        mWaitCheckInitCallback.block();
+    }
+
+    public void checkReadCallbackNotInvoked() {
+        mWaitCheckReadCallback.close();
+        nativeCheckReadCallbackNotInvoked(mUploadDataStreamHandler);
+        mWaitCheckReadCallback.block();
+    }
+
+    public String getData() {
+        return mData;
+    }
+
+    public void waitForReadComplete() {
+        mWaitReadComplete.block();
+    }
+
+    public void resetWaitForReadComplete() {
+        mWaitReadComplete.close();
+    }
+
+    public void resetWaitForInitComplete() {

[mmenke, 2015/02/18 21:06:23]

Rather than have these close() methods, couldn't your checkBlah methods have the
close at the end, not the start, and your waitForBlah also have the close right
after them?

Then you can also replace the current resetBlah() calls with
checkBlahCalbackNotInvoked(), which seems clearer.

[xunjieli, 2015/02/19 14:59:11]

Done. Great idea! Thanks for the suggestion. Definitely has made the code easier
to understand.

+        mWaitInitComplete.close();
+    }
+
+    public void waitForInitComplete() {
+        mWaitInitComplete.block();
+    }
+
+    // Called on network thread.
+    @CalledByNative
+    private void onInitCalled(int res) {
+        if (res == 0) {
+            mInitCompletedSynchronously = true;
+        } else {
+            mInitCompletedSynchronously = false;
+        }
+        mWaitInitCalled.open();
+    }
+
+    @CalledByNative
+    // Called on network thread.
+    private void onReadCompleted(int bytesRead, String data) {
+        mData = data;
+        mWaitReadComplete.open();
+    }
+
+    @CalledByNative
+    // Called on network thread.
+    private void onInitCompleted(int res) {
+        mWaitInitComplete.open();
+    }
+
+    @CalledByNative
+    // Called on network thread.
+    private void onResetCompleted() {
+        mWaitResetComplete.open();
+    }
+
+    @CalledByNative
+    // Called on network thread.
+    private void onCheckInitCallbackNotInvoked(boolean initCallbackNotInvoked) {
+        Assert.assertTrue(initCallbackNotInvoked);
+        mWaitCheckInitCallback.open();
+    }
+
+    @CalledByNative
+    // Called on network thread.
+    private void onCheckReadCallbackNotInvoked(boolean readCallbackNotInvoked) {
+        Assert.assertTrue(readCallbackNotInvoked);
+        mWaitCheckReadCallback.open();
+    }
+
+    @NativeClassQualifiedName("UploadDataStreamHandler")
+    private native void nativeInit(long nativePtr);
+
+    @NativeClassQualifiedName("UploadDataStreamHandler")
+    private native void nativeRead(long nativePtr);
+
+    @NativeClassQualifiedName("UploadDataStreamHandler")
+    private native void nativeReset(long nativePtr);
+
+    @NativeClassQualifiedName("UploadDataStreamHandler")
+    private native void nativeCheckInitCallbackNotInvoked(
+            long nativePtr);
+
+    @NativeClassQualifiedName("UploadDataStreamHandler")
+    private native void nativeCheckReadCallbackNotInvoked(
+            long nativePtr);
+
+    @NativeClassQualifiedName("UploadDataStreamHandler")
+    private native void nativeDestroy(long nativePtr);
+
+    private native long nativeCreateUploadDataStreamHandler(
+            long uploadDataStreamAdapter);
+}