• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2015 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 package org.chromium.net;
6 
7 import static com.google.common.truth.Truth.assertThat;
8 
9 import android.content.Context;
10 import android.os.ConditionVariable;
11 
12 import org.jni_zero.CalledByNative;
13 import org.jni_zero.JNINamespace;
14 import org.jni_zero.NativeClassQualifiedName;
15 import org.jni_zero.NativeMethods;
16 
17 import org.chromium.net.impl.CronetUrlRequestContext;
18 
19 /**
20  * A wrapper class on top of the native net::UploadDataStream. This class is
21  * used in tests to drive the native UploadDataStream directly.
22  */
23 @JNINamespace("cronet")
24 public final class TestUploadDataStreamHandler {
25     private final CronetTestUtil.NetworkThreadTestConnector mNetworkThreadTestConnector;
26     private final CronetEngine mCronetEngine;
27     private long mTestUploadDataStreamHandler;
28     private ConditionVariable mWaitInitCalled = new ConditionVariable();
29     private ConditionVariable mWaitInitComplete = new ConditionVariable();
30     private ConditionVariable mWaitReadComplete = new ConditionVariable();
31     private ConditionVariable mWaitResetComplete = new ConditionVariable();
32     // Waits for checkIfInitCallbackInvoked() returns result asynchronously.
33     private ConditionVariable mWaitCheckInit = new ConditionVariable();
34     // Waits for checkIfReadCallbackInvoked() returns result asynchronously.
35     private ConditionVariable mWaitCheckRead = new ConditionVariable();
36     // If true, init completes synchronously.
37     private boolean mInitCompletedSynchronously;
38     private String mData = "";
39 
TestUploadDataStreamHandler(Context context, final long uploadDataStream)40     public TestUploadDataStreamHandler(Context context, final long uploadDataStream) {
41         mCronetEngine = new CronetEngine.Builder(context).build();
42         mNetworkThreadTestConnector = new CronetTestUtil.NetworkThreadTestConnector(mCronetEngine);
43         CronetUrlRequestContext requestContext = (CronetUrlRequestContext) mCronetEngine;
44         mTestUploadDataStreamHandler =
45                 TestUploadDataStreamHandlerJni.get()
46                         .createTestUploadDataStreamHandler(
47                                 this,
48                                 uploadDataStream,
49                                 requestContext.getUrlRequestContextAdapter());
50     }
51 
destroyNativeObjects()52     public void destroyNativeObjects() {
53         if (mTestUploadDataStreamHandler != 0) {
54             TestUploadDataStreamHandlerJni.get().destroy(mTestUploadDataStreamHandler);
55             mTestUploadDataStreamHandler = 0;
56             mNetworkThreadTestConnector.shutdown();
57             mCronetEngine.shutdown();
58         }
59     }
60 
61     /** Init and returns whether init completes synchronously. */
init()62     public boolean init() {
63         mData = "";
64         TestUploadDataStreamHandlerJni.get().init(mTestUploadDataStreamHandler);
65         mWaitInitCalled.block();
66         mWaitInitCalled.close();
67         return mInitCompletedSynchronously;
68     }
69 
read()70     public void read() {
71         TestUploadDataStreamHandlerJni.get().read(mTestUploadDataStreamHandler);
72     }
73 
reset()74     public void reset() {
75         mData = "";
76         TestUploadDataStreamHandlerJni.get().reset(mTestUploadDataStreamHandler);
77         mWaitResetComplete.block();
78         mWaitResetComplete.close();
79     }
80 
81     /**
82      * Checks that {@link #onInitCompleted} has not invoked asynchronously
83      * by the native UploadDataStream.
84      */
checkInitCallbackNotInvoked()85     public void checkInitCallbackNotInvoked() {
86         TestUploadDataStreamHandlerJni.get()
87                 .checkInitCallbackNotInvoked(mTestUploadDataStreamHandler);
88         mWaitCheckInit.block();
89         mWaitCheckInit.close();
90     }
91 
92     /**
93      * Checks that {@link #onReadCompleted} has not been invoked asynchronously
94      * by the native UploadDataStream.
95      */
checkReadCallbackNotInvoked()96     public void checkReadCallbackNotInvoked() {
97         TestUploadDataStreamHandlerJni.get()
98                 .checkReadCallbackNotInvoked(mTestUploadDataStreamHandler);
99         mWaitCheckRead.block();
100         mWaitCheckRead.close();
101     }
102 
getData()103     public String getData() {
104         return mData;
105     }
106 
waitForReadComplete()107     public void waitForReadComplete() {
108         mWaitReadComplete.block();
109         mWaitReadComplete.close();
110     }
111 
waitForInitComplete()112     public void waitForInitComplete() {
113         mWaitInitComplete.block();
114         mWaitInitComplete.close();
115     }
116 
117     // Called on network thread.
118     @CalledByNative
onInitCalled(int res)119     private void onInitCalled(int res) {
120         if (res == 0) {
121             mInitCompletedSynchronously = true;
122         } else {
123             mInitCompletedSynchronously = false;
124         }
125         mWaitInitCalled.open();
126     }
127 
128     // Called on network thread.
129     @CalledByNative
onReadCompleted(int bytesRead, String data)130     private void onReadCompleted(int bytesRead, String data) {
131         mData = data;
132         mWaitReadComplete.open();
133     }
134 
135     // Called on network thread.
136     @CalledByNative
onInitCompleted(int res)137     private void onInitCompleted(int res) {
138         // If init() completed synchronously, waitForInitComplete() will
139         // not be invoked in the test, so skip mWaitInitComplete.open().
140         if (!mInitCompletedSynchronously) {
141             mWaitInitComplete.open();
142         }
143     }
144 
145     // Called on network thread.
146     @CalledByNative
onResetCompleted()147     private void onResetCompleted() {
148         mWaitResetComplete.open();
149     }
150 
151     // Called on network thread.
152     @CalledByNative
onCheckInitCallbackNotInvoked(boolean initCallbackNotInvoked)153     private void onCheckInitCallbackNotInvoked(boolean initCallbackNotInvoked) {
154         assertThat(initCallbackNotInvoked).isTrue();
155         mWaitCheckInit.open();
156     }
157 
158     // Called on network thread.
159     @CalledByNative
onCheckReadCallbackNotInvoked(boolean readCallbackNotInvoked)160     private void onCheckReadCallbackNotInvoked(boolean readCallbackNotInvoked) {
161         assertThat(readCallbackNotInvoked).isTrue();
162         mWaitCheckRead.open();
163     }
164 
165     @NativeMethods("cronet_tests")
166     interface Natives {
167         @NativeClassQualifiedName("TestUploadDataStreamHandler")
init(long nativePtr)168         void init(long nativePtr);
169 
170         @NativeClassQualifiedName("TestUploadDataStreamHandler")
read(long nativePtr)171         void read(long nativePtr);
172 
173         @NativeClassQualifiedName("TestUploadDataStreamHandler")
reset(long nativePtr)174         void reset(long nativePtr);
175 
176         @NativeClassQualifiedName("TestUploadDataStreamHandler")
checkInitCallbackNotInvoked(long nativePtr)177         void checkInitCallbackNotInvoked(long nativePtr);
178 
179         @NativeClassQualifiedName("TestUploadDataStreamHandler")
checkReadCallbackNotInvoked(long nativePtr)180         void checkReadCallbackNotInvoked(long nativePtr);
181 
182         @NativeClassQualifiedName("TestUploadDataStreamHandler")
destroy(long nativePtr)183         void destroy(long nativePtr);
184 
createTestUploadDataStreamHandler( TestUploadDataStreamHandler obj, long uploadDataStream, long contextAdapter)185         long createTestUploadDataStreamHandler(
186                 TestUploadDataStreamHandler obj, long uploadDataStream, long contextAdapter);
187     }
188 }
189