Add HttpUrlConnection backed implementation of CronetEngine.

components/cronet/android/api/src/org/chromium/net/CronetEngine.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 android.content.Context;
 import android.support.annotation.IntDef;
 import android.util.Log;
 
 import java.io.File;
+import java.io.IOException;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.reflect.Constructor;
 import java.net.IDN;
 import java.net.Proxy;
 import java.net.URL;
 import java.net.URLConnection;
 import java.net.URLStreamHandlerFactory;
 import java.util.Date;
 import java.util.HashSet;
@@ skipping 539 matching lines @@
      * priorities see {@link #createRequest(String, UrlRequest.Callback,
      * Executor, int priority)}.
      *
      * @param url {@link URL} for the request.
      * @param callback callback object that gets invoked on different events.
      * @param executor {@link Executor} on which all callbacks will be invoked.
      * @return new request.
      * @deprecated Use {@link UrlRequest.Builder#build}.
      */
     @Deprecated
-    public abstract UrlRequest createRequest(
-            String url, UrlRequest.Callback callback, Executor executor);
+    public final UrlRequest createRequest(
+            String url, UrlRequest.Callback callback, Executor executor) {
+        return createRequest(url, callback, executor, UrlRequest.Builder.REQUEST_PRIORITY_MEDIUM);
+    }
 
     /**
      * Creates a {@link UrlRequest} object. All callbacks will
      * be called on {@code executor}'s thread. {@code executor} must not run
      * tasks on the current thread to prevent blocking networking operations
      * and causing exceptions during shutdown.
      *
      * @param url {@link URL} for the request.
      * @param callback callback object that gets invoked on different events.
      * @param executor {@link Executor} on which all callbacks will be invoked.
@@ skipping 170 matching lines @@
 
     /**
      * Establishes a new connection to the resource specified by the {@link URL} {@code url}.
      * <p>
      * <b>Note:</b> Cronet's {@link java.net.HttpURLConnection} implementation is subject to certain
      * limitations, see {@link #createURLStreamHandlerFactory} for details.
      *
      * @param url URL of resource to connect to.
      * @return an {@link java.net.HttpURLConnection} instance implemented by this CronetEngine.
      */
-    public abstract URLConnection openConnection(URL url);
+    public abstract URLConnection openConnection(URL url) throws IOException;
 
     /**
      * Establishes a new connection to the resource specified by the {@link URL} {@code url}
      * using the given proxy.
      * <p>
      * <b>Note:</b> Cronet's {@link java.net.HttpURLConnection} implementation is subject to certain
      * limitations, see {@link #createURLStreamHandlerFactory} for details.
      *
      * @param url URL of resource to connect to.
      * @param proxy proxy to use when establishing connection.
      * @return an {@link java.net.HttpURLConnection} instance implemented by this CronetEngine.
      * @hide
      * @deprecated Marked as deprecated because @hide doesn't properly hide but
      *         javadocs are built with nodeprecated="yes".
      *         TODO(pauljensen): Expose once implemented, http://crbug.com/418111
      */
-    @SuppressWarnings("DepAnn") public abstract URLConnection openConnection(URL url, Proxy proxy);
+    @SuppressWarnings("DepAnn")
+    public abstract URLConnection openConnection(URL url, Proxy proxy) throws IOException;
 
     /**
      * Creates a {@link URLStreamHandlerFactory} to handle HTTP and HTTPS
      * traffic. An instance of this class can be installed via
      * {@link URL#setURLStreamHandlerFactory} thus using this CronetEngine by default for
      * all requests created via {@link URL#openConnection}.
      * <p>
      * Cronet does not use certain HTTP features provided via the system:
      * <ul>
      * <li>the HTTP cache installed via
@@ skipping 32 matching lines @@
     @Deprecated
     public static CronetEngine createContext(Builder builder) {
         CronetEngine cronetEngine = null;
         if (builder.getUserAgent() == null) {
             builder.setUserAgent(builder.getDefaultUserAgent());
         }
         if (!builder.legacyMode()) {
             cronetEngine = createCronetEngine(builder);
         }
         if (cronetEngine == null) {
-            // TODO(mef): Fallback to stub implementation. Once stub
-            // implementation is available merge with createCronetFactory.
-            cronetEngine = createCronetEngine(builder);
+            cronetEngine = new JavaCronetEngine(builder.getUserAgent());

[pauljensen, 2015/12/29 16:35:53]

I'm worried about this automatic silent fallback.  I dislike silent fallback
because embedders might try out Cronet and think it doesn't perform any better
than their existing HttpURLConnection code, but they could silently be using the
HttpURLConnection impl of Cronet.  Perhaps we should use the legacyMode()
plumbing we already have to control this fallback?  This code could be something
like:

if (builder.legacyMode()) {
  cronetEngine = new JavaCronetEngine(builder.getUserAgent());
} else {
  cronetEngine = createCronetEngine(builder);
}

[Charles, 2016/01/05 21:53:56]

The problem with that is that you now need a code change in order to use the
java impl - this means that you have to have two different source files when
building, rather than making the decision based on the structure of the build
graph alone. If you want, I could add a log statement that provides an explicit
warning about the fact that we're loading the legacy version of the stack. Would
assuage your concerns?

         }
         Log.i(TAG, "Using network stack: " + cronetEngine.getVersionString());
         return cronetEngine;
     }
 
     private static CronetEngine createCronetEngine(Builder builder) {
         CronetEngine cronetEngine = null;
         try {
             Class<? extends CronetEngine> engineClass =
                     CronetEngine.class.getClassLoader()
                             .loadClass(CRONET_URL_REQUEST_CONTEXT)
                             .asSubclass(CronetEngine.class);
             Constructor<? extends CronetEngine> constructor =
                     engineClass.getConstructor(Builder.class);
             CronetEngine possibleEngine = constructor.newInstance(builder);
             if (possibleEngine.isEnabled()) {
                 cronetEngine = possibleEngine;
             }
         } catch (ClassNotFoundException e) {
             // Leave as null.
         } catch (Exception e) {
             throw new IllegalStateException("Cannot instantiate: " + CRONET_URL_REQUEST_CONTEXT, e);
         }
         return cronetEngine;
     }
 }