[Cronet] Test the libcronet that's shipped, not libcronet_test

components/cronet/android/test/src/org/chromium/net/CronetTestUtil.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;
 
 import android.os.ConditionVariable;
+import android.os.Handler;
+import android.os.Looper;
 
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.net.impl.CronetUrlRequest;
-import org.json.JSONException;
-import org.json.JSONObject;
+
+import java.nio.ByteBuffer;
+import java.util.concurrent.Executor;
 
 /**
  * Utilities for Cronet testing
  */
 @JNINamespace("cronet")
 public class CronetTestUtil {
     private static final ConditionVariable sHostResolverBlock = new ConditionVariable();
+    private static CronetEngine sCronetEngineWithPreparedNetworkThread;

[kapishnikov, 2016/10/20 17:25:46]

It would be great if we can avoid 'static' here.

[pauljensen, 2016/10/24 18:52:53]

Done.

 
     static final String SDCH_FAKE_HOST = "fake.sdch.domain";
     // QUIC test domain must match the certificate used
     // (quic_test.example.com.crt and quic_test.example.com.key.pkcs8), and
     // the file served (
     // components/cronet/android/test/assets/test/quic_data/simple.txt).
     static final String QUIC_FAKE_HOST = "test.example.com";
     private static final String[] TEST_DOMAINS = {SDCH_FAKE_HOST, QUIC_FAKE_HOST};
     private static final String LOOPBACK_ADDRESS = "127.0.0.1";
 
@@ skipping 21 matching lines @@
      */
     public static JSONObject generateHostResolverRules(String destination) throws JSONException {
         StringBuilder rules = new StringBuilder();
         for (String domain : TEST_DOMAINS) {
             rules.append("MAP " + domain + " " + destination + ",");
         }
         return new JSONObject().put("host_resolver_rules", rules);
     }
 
     /**
+     * Run {@code r} on {@code engine}'s network thread.
+     */
+    public static void postToNetworkThread(final CronetEngine engine, final Runnable r) {
+        // This method works by creating a UrlRequest with {@code engine} and using a
+        // direct-executor to execute on {@code engine}'s network thread.  The UrlRequest
+        // goes to a bogus URL which immediately triggers {@link UrlRequest#Callback#onFailed}.
+
+        // UrlRequests cannot be created on the network thread (see DCHECK in
+        // CronetURLRequestAdapter()), so this method must first post over to the main thread,
+        // in case it was called on the network thread.
+        new Handler(Looper.getMainLooper()).post(new Runnable() {
+            @Override
+            public void run() {
+                Executor directExecutor = new Executor() {
+                    @Override
+                    public void execute(Runnable runable) {
+                        runable.run();
+                    }
+                };
+                UrlRequest.Callback callback = new UrlRequest.Callback() {
+                    @Override
+                    public void onRedirectReceived(UrlRequest request, UrlResponseInfo responseInfo,
+                            String newLocationUrl) {}
+
+                    @Override
+                    public void onResponseStarted(
+                            UrlRequest request, UrlResponseInfo responseInfo) {}
+
+                    @Override
+                    public void onReadCompleted(UrlRequest request, UrlResponseInfo responseInfo,
+                            ByteBuffer byteBuffer) {}
+
+                    @Override
+                    public void onSucceeded(UrlRequest request, UrlResponseInfo responseInfo) {}
+
+                    @Override
+                    public void onFailed(UrlRequest request, UrlResponseInfo responseInfo,
+                            UrlRequestException error) {
+                        r.run();
+                    }
+                };
+                // Bogus empty URL will trigger onFailed() immediately.
+                new UrlRequest.Builder("", callback, directExecutor, engine).build().start();
+            }
+        });
+    }
+
+    /**
+     * Prepare {@code cronetEngine}'s network thread so libcronet_test code can run on it.
+     */
+    public static void prepareNetworkThreadForTesting(final CronetEngine cronetEngine) {
+        sCronetEngineWithPreparedNetworkThread = cronetEngine;
+        final ConditionVariable initDone = new ConditionVariable();
+        postToNetworkThread(cronetEngine, new Runnable() {
+            @Override
+            public void run() {
+                nativePrepareNetworkThreadForTesting();
+                initDone.open();
+            }
+        });
+        // Don't return until network thread is prepared.  Some test call
+        // {@code cronetEngine.shutdown} immediatly after calling this function, which will fail
+        // if postToNetworkThread() isn't finished running a UrlRequest with {@code cronetEngine}.
+        initDone.block();
+    }
+
+    /**
+     * Get pointer to SingleThreadTaskRunner created by {@link #prepareNetworkThreadForTesting}.
+     */
+    public static long getNativeSingleThreadTaskRunner() {
+        return nativeGetNativeSingleThreadTaskRunner();
+    }
+
+    /**
+     * Clean up preparation performed by {@link #prepareNetworkThreadForTesting}.
+     */
+    public static void cleanupNetorkThreadForTesting() {
+        final ConditionVariable cleanupDone = new ConditionVariable();
+        postToNetworkThread(sCronetEngineWithPreparedNetworkThread, new Runnable() {
+            @Override
+            public void run() {
+                nativeCleanupNetorkThreadForTesting();
+                cleanupDone.open();
+            }
+        });
+        // Don't return until network thread is cleaned up.  Some test call
+        // {@code cronetEngine.shutdown} immediatly after calling this function, which will fail
+        // if postToNetworkThread() isn't finished running a UrlRequest with {@code cronetEngine}.
+        cleanupDone.block();
+    }
+
+    /**
+     * Execute base::Closure pointed to by {@code closure} on network thread.
+     */
+    @CalledByNative
+    private static void postClosureToNetworkThread(final long closure) {
+        CronetTestUtil.postToNetworkThread(sCronetEngineWithPreparedNetworkThread, new Runnable() {
+            @Override
+            public void run() {
+                nativeRunClosure(closure);
+            }
+        });
+    }
+
+    /**
      * Returns the value of load flags in |urlRequest|.
      * @param urlRequest is the UrlRequest object of interest.
      */
     public static int getLoadFlags(UrlRequest urlRequest) {
-        return nativeGetLoadFlags(((CronetUrlRequest) urlRequest).getUrlRequestAdapterForTesting());
+        return nativeGetLoadFlags(((CronetUrlRequest) urlRequest).getUrlRequestForTesting());
     }
 
     private static native int nativeGetLoadFlags(long urlRequest);
+
+    private static native void nativePrepareNetworkThreadForTesting();

[kapishnikov, 2016/10/20 17:25:46]

A static method with no context. This limits us to one engine.

+    private static native long nativeGetNativeSingleThreadTaskRunner();
+    private static native void nativeCleanupNetorkThreadForTesting();
+    private static native void nativeRunClosure(long closure);
 }