Cronet: a framework for providing alternative Cronet implementations

components/cronet/android/test/javatests/src/org/chromium/net/CronetTestBase.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.test.AndroidTestCase;
 
 import org.chromium.base.ContextUtils;
 import org.chromium.base.PathUtils;
 import org.chromium.net.impl.CronetEngineBase;
 import org.chromium.net.impl.JavaCronetEngine;
+import org.chromium.net.impl.JavaCronetProvider;
 import org.chromium.net.impl.UserAgent;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 import java.lang.reflect.AnnotatedElement;
 import java.net.URL;
+import java.util.List;
 
 /**
  * Base test class for all CronetTest based tests.
  */
 public class CronetTestBase extends AndroidTestCase {
     private static final String PRIVATE_DATA_DIRECTORY_SUFFIX = "cronet_test";
     private static final String LOOPBACK_ADDRESS = "127.0.0.1";
 
     private CronetTestFramework mCronetTestFramework;
     // {@code true} when test is being run against system HttpURLConnection implementation.
@@ skipping 94 matching lines @@
                 }
             } catch (Throwable e) {
                 throw new Throwable("CronetTestBase#runTest failed.", e);
             }
         } else if (packageName.equals("org.chromium.net")) {
             try {
                 AnnotatedElement method = getClass().getMethod(getName(), (Class[]) null);
                 super.runTest();
                 if (!method.isAnnotationPresent(OnlyRunNativeCronet.class)) {
                     if (mCronetTestFramework != null) {
-                        ExperimentalCronetEngine.Builder builder =
-                                new ExperimentalCronetEngine.Builder(getContext());
+                        ExperimentalCronetEngine.Builder builder = createJavaEngineBuilder();
                         builder.setUserAgent(UserAgent.from(getContext()));
-                        builder.enableLegacyMode(true);
                         mCronetTestFramework.mCronetEngine = (CronetEngineBase) builder.build();
                         // Make sure that the instantiated engine is JavaCronetEngine.
                         assert mCronetTestFramework.mCronetEngine.getClass()
                                 == JavaCronetEngine.class;
                     }
                     mTestingJavaImpl = true;
                     super.runTest();
                 }
             } catch (Throwable e) {
                 throw new Throwable("CronetTestBase#runTest failed.", e);
             }
         } else {
             super.runTest();
         }
     }
 
+    /**
+     * Creates and returns {@link ExperimentalCronetEngine.Builder} that creates
+     * Java (platform) based {@link CronetEngine.Builder}.
+     *
+     * @return the {@code CronetEngine.Builder} that builds Java-based {@code Cronet engine}.
+     */
+    ExperimentalCronetEngine.Builder createJavaEngineBuilder() {
+        CronetProvider provider = findJavaCronetProvider();
+        return (ExperimentalCronetEngine.Builder) provider.createBuilder();

[pauljensen, 2017/01/18 17:03:05]

why not just make this "return new JavaCronetProvider().createBuilder();"?

[kapishnikov, 2017/01/19 01:25:25]

Some tests rely on features that are available in the experimental builder only.
This method can be called from a test. We can explicitly cast everywhere an
experimental feature is needed and return CronetEngine.Builder here.

[pauljensen, 2017/01/20 17:13:34]

How about:
(ExperimentalCronetEngine.Builder) new JavaCronetProvider().createBuilder()

[kapishnikov, 2017/01/20 21:48:38]

That is a great suggestion. I tried to avoid referencing the internal classes in
our tests to improve code coverage but I think in this case it is justified. We
already have a smoke test that uses Providers to create the Java engine. Done.

+    }
+
+    /**
+     * Finds {@link CronetProvider} that can be used to create Java-based {@link CronetEngine}.
+     *
+     * @return the found provider.
+     */
+    private CronetProvider findJavaCronetProvider() {
+        List<CronetProvider> availableProviders =
+                CronetProviders.instance().getAvailableProviders(getContext());
+        for (CronetProvider provider : availableProviders) {
+            if (provider.getName().equals(JavaCronetProvider.PROVIDER_NAME)) {
+                return provider;
+            }
+        }
+        throw new AssertionError("Unable to find Java Provider");
+    }
+
     public void assertResponseEquals(UrlResponseInfo expected, UrlResponseInfo actual) {
         assertEquals(expected.getAllHeaders(), actual.getAllHeaders());
         assertEquals(expected.getAllHeadersAsList(), actual.getAllHeadersAsList());
         assertEquals(expected.getHttpStatusCode(), actual.getHttpStatusCode());
         assertEquals(expected.getHttpStatusText(), actual.getHttpStatusText());
         assertEquals(expected.getUrlChain(), actual.getUrlChain());
         assertEquals(expected.getUrl(), actual.getUrl());
         // Transferred bytes and proxy server are not supported in pure java
         if (!(mCronetTestFramework.mCronetEngine instanceof JavaCronetEngine)) {
             assertEquals(expected.getReceivedByteCount(), actual.getReceivedByteCount());
@@ skipping 18 matching lines @@
 
     @Target(ElementType.METHOD)
     @Retention(RetentionPolicy.RUNTIME)
     public @interface OnlyRunCronetHttpURLConnection {
     }
 
     @Target(ElementType.METHOD)
     @Retention(RetentionPolicy.RUNTIME)
     public @interface OnlyRunNativeCronet {}
 }