Enable NQE when Cronet Engine is built

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.annotation.SuppressLint;
 import android.content.Context;
 import android.net.http.HttpResponseCache;
 import android.support.annotation.IntDef;
@@ skipping 101 matching lines @@
         private boolean mSdchEnabled;
         private String mDataReductionProxyKey;
         private String mDataReductionProxyPrimaryProxy;
         private String mDataReductionProxyFallbackProxy;
         private String mDataReductionProxySecureProxyCheckUrl;
         private boolean mDisableCache;
         private int mHttpCacheMode;
         private long mHttpCacheMaxSize;
         private String mExperimentalOptions;
         private long mMockCertVerifier;
+        private boolean mNetworkQualityEstimatorEnabled;
 
         /**
          * Default config enables SPDY, disables QUIC, SDCH and HTTP cache.
          * @param context Android {@link Context} for engine to use.
          */
         public Builder(Context context) {
             mContext = context;
             setLibraryName("cronet");
             enableLegacyMode(false);
             enableQUIC(false);
             enableHTTP2(true);
             enableSDCH(false);
             enableHttpCache(HTTP_CACHE_DISABLED, 0);
+            enableNetworkQualityEstimator(false);
         }
 
         /**
          * Constructs a User-Agent string including application name and version,
          * system build version, model and id, and Cronet version.
          *
          * @return User-Agent string.
          */
         public String getDefaultUserAgent() {
             return UserAgent.from(mContext);
@@ skipping 449 matching lines @@
         Builder setMockCertVerifierForTesting(long mockCertVerifier) {
             mMockCertVerifier = mockCertVerifier;
             return this;
         }
 
         long mockCertVerifier() {
             return mMockCertVerifier;
         }
 
         /**
+         * Enables the network quality estimator, which collects and reports
+         * measurements of round trip time (RTT) and downstream throughput at
+         * various layers of the network stack. After enabling the estimator,
+         * listeners of RTT and throughput can be added with
+         * {@link #addRttListener} and {@link #addThroughputListener} and
+         * removed with {@link #removeRttListener} and
+         * {@link #removeThroughputListener}. The estimator uses memory and CPU
+         * only when enabled.
+         * @param value {@code true} to enable network quality estimator,
+         *            {@code false} to disable.
+         * @hide as it's a prototype.
+         * @return the builder to facilitate chaining.
+         */
+        public Builder enableNetworkQualityEstimator(boolean value) {
+            if (!value) {

[mef, 2016/06/20 16:50:27]

I think for Builder it is ok to be able to turn it on and off until actual
CronetEngine is built, so I would just store the value in
mNetworkQualityEstimatorEnabled and don't throw any exceptions.

[tbansal1, 2016/06/20 20:06:57]

Done.

+                return this;
+            }
+
+            if (mNetworkQualityEstimatorEnabled) {
+                throw new IllegalStateException("Network quality estimator is already initialized");
+            }
+            mNetworkQualityEstimatorEnabled = true;
+            return this;
+        }
+
+        /**
+         * @return true if the network quality estimator has been enabled for
+         * this builder.
+         * @hide as it's a prototype.
+         */
+        boolean networkQualityEstimatorEnabled() {
+            return mNetworkQualityEstimatorEnabled;
+        }
+
+        /**
          * Returns {@link Context} for builder.
          *
          * @return {@link Context} for builder.
          */
         Context getContext() {
             return mContext;
         }
 
         /**
          * Build a {@link CronetEngine} using this builder's configuration.
@@ skipping 169 matching lines @@
      * useful data as no metrics have yet been collected.
      *
      * @return differences in metrics collected by Cronet, since the last call
      *         to {@code getGlobalMetricsDeltas()}, serialized as a
      *         <a href=https://developers.google.com/protocol-buffers>protobuf
      *         </a>.
      */
     public abstract byte[] getGlobalMetricsDeltas();
 
     /**
+     * Sets the executor which will be used to notify RequestFinished
+     *             listeners, and to notify network quality RTT listeners
+     *             that do not provide an executor.
+     * TODO(tbansal):  http://crbug.com/618034 Remove this API. In short term,
+     * once all Cronet embedders supply a valid executor with
+     * NetworkQualityRTTListener, update the above comment to reflect that
+     * {@link executor} is only used to notify RequestFinishedListeners.
+     * @hide as it's a prototype.
+     */
+    public abstract void setRequestFinishedListenerExecutor(Executor executor);
+
+    /**
      * Enables the network quality estimator, which collects and reports
      * measurements of round trip time (RTT) and downstream throughput at
      * various layers of the network stack. After enabling the estimator,
      * listeners of RTT and throughput can be added with
      * {@link #addRttListener} and {@link #addThroughputListener} and
      * removed with {@link #removeRttListener} and
      * {@link #removeThroughputListener}. The estimator uses memory and CPU
      * only when enabled.
      * @param executor an executor that will be used to notified all
      *            added RTT and throughput listeners.
+     * TODO(tbansal):  http://crbug.com/618034 Remove this API.
      * @hide as it's a prototype.
      */
     public abstract void enableNetworkQualityEstimator(Executor executor);
 
     /**
-     * Enables the network quality estimator for testing. This must be called
-     * before round trip time and throughput listeners are added. Set both
-     * boolean parameters to false for default behavior.
+     * 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.
-     * @param executor an {@link java.util.concurrent.Executor} on which all
-     *            listeners will be called.
+     * @param useSmallerResponses include small responses in throughput
+     * estimates.
      * @hide as it's a prototype.
      */
-    abstract void enableNetworkQualityEstimatorForTesting(
-            boolean useLocalHostRequests, boolean useSmallerResponses, Executor executor);
+    abstract 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 #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 #enableNetworkQualityEstimator}.
      * @param listener the listener of round trip times.
@@ skipping 142 matching lines @@
      * Registers a listener that gets called after the end of each request with the request info.
      *
      * <p>This must be called after {@link #enableNetworkQualityEstimator} and will throw an
      * exception otherwise.
      *
      * <p>The listener is called on the {@link java.util.concurrent.Executor} that
      * is passed to {@link #enableNetworkQualityEstimator}.
      *
      * @param listener the listener for finished requests.
      *
+     * TODO(tbansal):  http://crbug.com/618034 Remove this API, once all embedders have switched to
+     * using a request finished listener that provides its own executor.
      * @hide as it's a prototype.
      */
     public abstract void addRequestFinishedListener(RequestFinishedListener listener);
 
     /**
      * Removes a finished request listener.
      *
      * @param listener the listener to remove.
      *
+     * TODO(tbansal):  http://crbug.com/618034 Remove this API, once all embedders have switched to
+     * using a request finished listener that provides its own executor.
      * @hide it's a prototype.
      */
     public abstract void removeRequestFinishedListener(RequestFinishedListener listener);
 
     /**
      * Information about a finished request. Passed to {@link RequestFinishedListener}.
      *
      * @hide as it's a prototype.
      */
     public static final class UrlRequestInfo {
@@ skipping 100 matching lines @@
          */
         @Nullable
         public Long getReceivedBytesCount() {
             return mReceivedBytesCount;
         }
     }
 
     /**
      * Interface to listen for finished requests that were created via this CronetEngine instance.
      *
+     * TODO(tbansal):  http://crbug.com/618034 Remove this API, and replace it with a listener
+     * whose executor is bound to the lifetime of the listener.
      * @hide as it's a prototype.
      */
-    public interface RequestFinishedListener { // TODO(klm): Add a convenience abstract class.
+    public interface RequestFinishedListener {
         /**
          * Invoked with request info.
          * @param requestInfo {@link UrlRequestInfo} for finished request.
          */
         void onRequestFinished(UrlRequestInfo requestInfo);
     }
 }