Add default implementation of experimental methods

components/cronet/android/api/src/org/chromium/net/ExperimentalCronetEngine.java

 // Copyright 2016 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.VisibleForTesting;
 
 import java.io.IOException;
 import java.net.Proxy;
 import java.net.URL;
 import java.net.URLConnection;
 import java.util.Date;
 import java.util.Set;
 import java.util.concurrent.Executor;
 
 /**
  * {@link CronetEngine} that exposes experimental features. Use {@link Builder} to build an
  * instance of this class. Every instance of {@link CronetEngine} can be casted to an instance
  * of this class.
  *
  * {@hide since this class exposes experimental features that should be hidden.}
  */
 public abstract class ExperimentalCronetEngine extends CronetEngine {
     /**
+     * Unknown rtt throughput value.

[pauljensen, 2016/11/08 14:00:32]

What is "rtt throughput"?
rtt should be capitalized as it's an abreviation.

[kapishnikov, 2016/11/08 15:29:45]

Renamed to CONNECTION_METRIC_UNKNOWN and changed the description accordingly.

+     */
+    public static final int RTT_THROUGHPUT_UNKNOWN = -1;

[pauljensen, 2016/11/08 14:00:32]

We need a better name than "RTT_THROUGHPUT". Perhaps CONNECTION_METRIC_UNKNOWN?

[kapishnikov, 2016/11/08 15:29:45]

Done.

+
+    /**
+     * The connection type is unknown.

[pauljensen, 2016/11/08 14:00:32]

This needs a lot more description.  It should mention that this is an estimate
and should @link to the function that returns this value.  Ditto for the other
values.

Here's something I wrote up a couple months ago:
https://codereview.chromium.org/2337233003/diff/1/net/nqe/effective_connectio...

[kapishnikov, 2016/11/08 15:29:45]

Done.

+     */
+    public static final int EFFECTIVE_CONNECTION_TYPE_UNKNOWN = 0;
+
+    /**
+     * The device is offline.
+     */
+    public static final int EFFECTIVE_CONNECTION_TYPE_OFFLINE = 1;
+
+    /**
+     * The connection type is slow 2G.
+     */
+    public static final int EFFECTIVE_CONNECTION_TYPE_SLOW_2G = 2;
+
+    /**
+     * The connection type is 2G.
+     */
+    public static final int EFFECTIVE_CONNECTION_TYPE_2G = 3;
+
+    /**
+     * The connection type is 3G.
+     */
+    public static final int EFFECTIVE_CONNECTION_TYPE_3G = 4;
+
+    /**
+     * The connection type is 4G.
+     */
+    public static final int EFFECTIVE_CONNECTION_TYPE_4G = 5;
+
+    /**
      * Builder for building {@link ExperimentalCronetEngine}.
      */
     public static class Builder extends CronetEngine.Builder {
         /**
          * Default config enables SPDY, disables QUIC, SDCH and HTTP cache.
          *
          * @param context Android {@link Context} for engine to use.
          */
         public Builder(Context context) {
             super(context);
@@ skipping 192 matching lines @@
      *            NetLog files must not already exist in the directory. If actively logging,
      *            this method is ignored.
      * @param logAll {@code true} to include basic events, user cookies,
      *            credentials and all transferred bytes in the log. This option presents a
      *            privacy risk, since it exposes the user's credentials, and should only be
      *            used with the user's consent and in situations where the log won't be public.
      *            {@code false} to just include basic events.
      * @param maxSize the maximum total disk space in bytes that should be used by NetLog. Actual
      *            disk space usage may exceed this limit slightly.
      */
-    public abstract void startNetLogToDisk(String dirPath, boolean logAll, int maxSize);
+    public void startNetLogToDisk(String dirPath, boolean logAll, int maxSize){};
 
     /**
      * Returns the effective connection type computed by the network quality
      * estimator.

[pauljensen, 2016/11/08 14:00:32]

Add "Call {@link Builder#enableNetworkQualityEstimator} to begin computing this
value."

[kapishnikov, 2016/11/08 15:29:45]

Done.

      */
-    public abstract int getEffectiveConnectionType();
+    public int getEffectiveConnectionType() {
+        return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
+    };
 
     /**
      * Configures the network quality estimator for testing. This must be called
      * before round trip time and throughput listeners are added, and after the
      * network quality estimator has been enabled.
      * @param useLocalHostRequests include requests to localhost in estimates.
      * @param useSmallerResponses include small responses in throughput
      * estimates.
      */
-    public abstract void configureNetworkQualityEstimatorForTesting(
-            boolean useLocalHostRequests, boolean useSmallerResponses);
+    public void configureNetworkQualityEstimatorForTesting(
+            boolean useLocalHostRequests, boolean useSmallerResponses){};
 
     /**
      * Registers a listener that gets called whenever the network quality
      * estimator witnesses a sample round trip time. This must be called
      * after {@link Builder#enableNetworkQualityEstimator}, and with throw an
      * exception otherwise. Round trip times may be recorded at various layers
      * of the network stack, including TCP, QUIC, and at the URL request layer.
      * The listener is called on the {@link java.util.concurrent.Executor} that
      * is passed to {@link Builder#enableNetworkQualityEstimator}.
      * @param listener the listener of round trip times.
      */
-    public abstract void addRttListener(NetworkQualityRttListener listener);
+    public void addRttListener(NetworkQualityRttListener listener){};
 
     /**
      * Removes a listener of round trip times if previously registered with
      * {@link #addRttListener}. This should be called after a
      * {@link NetworkQualityRttListener} is added in order to stop receiving
      * observations.
      * @param listener the listener of round trip times.
      */
-    public abstract void removeRttListener(NetworkQualityRttListener listener);
+    public void removeRttListener(NetworkQualityRttListener listener){};
 
     /**
      * Registers a listener that gets called whenever the network quality
      * estimator witnesses a sample throughput measurement. This must be called
      * after {@link Builder#enableNetworkQualityEstimator}. Throughput observations
      * are computed by measuring bytes read over the active network interface
      * at times when at least one URL response is being received. The listener
      * is called on the {@link java.util.concurrent.Executor} that is passed to
      * {@link Builder#enableNetworkQualityEstimator}.
      * @param listener the listener of throughput.
      */
-    public abstract void addThroughputListener(NetworkQualityThroughputListener listener);
+    public void addThroughputListener(NetworkQualityThroughputListener listener){};
 
     /**
      * Removes a listener of throughput. This should be called after a
      * {@link NetworkQualityThroughputListener} is added with
      * {@link #addThroughputListener} in order to stop receiving observations.
      * @param listener the listener of throughput.
      */
-    public abstract void removeThroughputListener(NetworkQualityThroughputListener listener);
+    public void removeThroughputListener(NetworkQualityThroughputListener listener){};
 
     /**
      * 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.
      * @throws IOException if an error occurs while opening the connection.
      */
     // TODO(pauljensen): Expose once implemented, http://crbug.com/418111
-    public abstract URLConnection openConnection(URL url, Proxy proxy) throws IOException;
+    public URLConnection openConnection(URL url, Proxy proxy) throws IOException {
+        return url.openConnection(proxy);
+    }
 
     /**
      * Registers a listener that gets called after the end of each request with the request info.
      *
      * <p>The listener is called on an {@link java.util.concurrent.Executor} provided by the
      * listener.
      *
      * @param listener the listener for finished requests.
      */
-    public abstract void addRequestFinishedListener(RequestFinishedInfo.Listener listener);
+    public void addRequestFinishedListener(RequestFinishedInfo.Listener listener){};
 
     /**
      * Removes a finished request listener.
      *
      * @param listener the listener to remove.
      */
-    public abstract void removeRequestFinishedListener(RequestFinishedInfo.Listener listener);
+    public void removeRequestFinishedListener(RequestFinishedInfo.Listener listener){};
 
     /**
      * Returns serialized representation of certificate verifier's cache
      * which contains the list of hosts/certificates and the certificate
      * verification results. May block until data is received from the network
      * thread (will timeout after the specified timeout). In case of timeout, it
      * returns the previous saved value.
      *
      * @param timeout in milliseconds. If timeout is 0, it will use default value.
      * @return serialized representation of certificate verification results
      *         data.
      */
-    public abstract String getCertVerifierData(long timeout);
+    public String getCertVerifierData(long timeout) {
+        return "";
+    };
 
     /**
      * Returns the HTTP RTT estimate (in milliseconds) computed by the network
-     * quality estimator. Set to
-     * {@link RttThroughputValues.INVALID_RTT_THROUGHPUT} if a valid value
+     * quality estimator. Set to {@link #RTT_THROUGHPUT_UNKNOWN} if a valid value

[pauljensen, 2016/11/08 14:00:32]

"if a valid value is unavailable" made more sense with INVALID, but perhaps we
should say something like "UNKNOWN if no estimate is available".  Ditto for
others.

[kapishnikov, 2016/11/08 15:29:45]

Changed to CONNECTION_METRIC_UNKNOWN + made small changes to the text. PTAL

      * is unavailable. This must be called after
      * {@link Builder#enableNetworkQualityEstimator}, and will throw an
      * exception otherwise.
      * @return Estimate of the HTTP RTT in milliseconds.
      */
-    public abstract int getHttpRttMs();
+    public int getHttpRttMs() {
+        return RTT_THROUGHPUT_UNKNOWN;
+    };
 
     /**
      * Returns the transport RTT estimate (in milliseconds) computed by the
-     * network quality estimator. Set to
-     * {@link RttThroughputValues.INVALID_RTT_THROUGHPUT} if a valid value is
-     * unavailable.  This must be called after
+     * network quality estimator. Set to {@link #RTT_THROUGHPUT_UNKNOWN} if
+     * a valid value is unavailable. This must be called after
      * {@link Builder#enableNetworkQualityEstimator}, and will throw an
      * exception otherwise.
      * @return Estimate of the transport RTT in milliseconds.
      */
-    public abstract int getTransportRttMs();
+    public int getTransportRttMs() {
+        return RTT_THROUGHPUT_UNKNOWN;
+    }
 
     /**
      * Returns the downstream throughput estimate (in kilobits per second)
      * computed by the network quality estimator. Set to
-     * {@link RttThroughputValues.INVALID_RTT_THROUGHPUT} if a valid value is
+     * {@link #RTT_THROUGHPUT_UNKNOWN} if a valid value is
      * unavailable.  This must be called after
      * {@link Builder#enableNetworkQualityEstimator}, and will
      * throw an exception otherwise.
      * @return Estimate of the downstream throughput in kilobits per second.
      */
-    public abstract int getDownstreamThroughputKbps();
+    public int getDownstreamThroughputKbps() {
+        return RTT_THROUGHPUT_UNKNOWN;
+    };
 }