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 {
     /**
+     * The value of a connection metric is unknown.
+     */
+    public static final int CONNECTION_METRIC_UNKNOWN = -1;
+
+    /**
+     * The estimate of the effective connection type is unknown.
+     *
+     * @see #getEffectiveConnectionType
+     */
+    public static final int EFFECTIVE_CONNECTION_TYPE_UNKNOWN = 0;
+
+    /**
+     * The device is offline.
+     *
+     * @see #getEffectiveConnectionType
+     */
+    public static final int EFFECTIVE_CONNECTION_TYPE_OFFLINE = 1;
+
+    /**
+     * The estimate of the effective connection type is slow 2G.
+     *
+     * @see #getEffectiveConnectionType
+     */
+    public static final int EFFECTIVE_CONNECTION_TYPE_SLOW_2G = 2;
+
+    /**
+     * The estimate of the effective connection type is 2G.
+     *
+     * @see #getEffectiveConnectionType
+     */
+    public static final int EFFECTIVE_CONNECTION_TYPE_2G = 3;
+
+    /**
+     * The estimate of the effective connection type is 3G.
+     *
+     * @see #getEffectiveConnectionType
+     */
+    public static final int EFFECTIVE_CONNECTION_TYPE_3G = 4;
+
+    /**
+     * The estimate of the effective connection type is 4G.
+     *
+     * @see #getEffectiveConnectionType
+     */
+    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.
+     * Returns an estimate of the effective connection type computed by the network quality
+     * estimator. Call {@link Builder#enableNetworkQualityEstimator} to begin computing this
+     * value.
+     *
+     * @return the estimated connection type. The returned value is one of
+     * {@link #EFFECTIVE_CONNECTION_TYPE_UNKNOWN EFFECTIVE_CONNECTION_TYPE_* }.
      */
-    public abstract int getEffectiveConnectionType();
+    public int getEffectiveConnectionType() {
+        return EFFECTIVE_CONNECTION_TYPE_UNKNOWN;
+    };

[pauljensen, 2016/11/09 19:55:16]

please remove all these semicolons after the }'s

[kapishnikov, 2016/11/09 20:17:19]

Done.

 
     /**
      * 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 #CONNECTION_METRIC_UNKNOWN} if the value
      * 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 CONNECTION_METRIC_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 #CONNECTION_METRIC_UNKNOWN} if
+     * the 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 CONNECTION_METRIC_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
-     * unavailable.  This must be called after
+     * {@link #CONNECTION_METRIC_UNKNOWN} if the 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 CONNECTION_METRIC_UNKNOWN;
+    };
 }