Enable NQE when Cronet Engine is built

components/cronet/android/java/src/org/chromium/net/CronetUrlRequestContext.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.content.Context;
 import android.os.Build;
 import android.os.ConditionVariable;
 import android.os.Handler;
@@ skipping 67 matching lines @@
     @UsedByReflection("CronetEngine.java")
     public CronetUrlRequestContext(final CronetEngine.Builder builder) {
         CronetLibraryLoader.ensureInitialized(builder.getContext(), builder);
         nativeSetMinLogLevel(getLoggingLevel());
         synchronized (mLock) {
             mUrlRequestContextAdapter = nativeCreateRequestContextAdapter(
                     createNativeUrlRequestContextConfig(builder.getContext(), builder));
             if (mUrlRequestContextAdapter == 0) {
                 throw new NullPointerException("Context Adapter creation failed.");
             }
+            mNetworkQualityEstimatorEnabled = builder.networkQualityEstimatorEnabled();
         }
 
         // Init native Chromium URLRequestContext on main UI thread.
         Runnable task = new Runnable() {
             @Override
             public void run() {
                 CronetLibraryLoader.ensureInitializedOnMainThread(builder.getContext());
                 synchronized (mLock) {
                     // mUrlRequestContextAdapter is guaranteed to exist until
                     // initialization on main and network threads completes and
@@ skipping 12 matching lines @@
 
     static long createNativeUrlRequestContextConfig(
             final Context context, CronetEngine.Builder builder) {
         final long urlRequestContextConfig = nativeCreateRequestContextConfig(
                 builder.getUserAgent(), builder.storagePath(), builder.quicEnabled(),
                 builder.getDefaultQuicUserAgentId(context), builder.http2Enabled(),
                 builder.sdchEnabled(), builder.dataReductionProxyKey(),
                 builder.dataReductionProxyPrimaryProxy(), builder.dataReductionProxyFallbackProxy(),
                 builder.dataReductionProxySecureProxyCheckUrl(), builder.cacheDisabled(),
                 builder.httpCacheMode(), builder.httpCacheMaxSize(), builder.experimentalOptions(),
-                builder.mockCertVerifier());
+                builder.mockCertVerifier(), builder.networkQualityEstimatorEnabled());
         for (Builder.QuicHint quicHint : builder.quicHints()) {
             nativeAddQuicHint(urlRequestContextConfig, quicHint.mHost, quicHint.mPort,
                     quicHint.mAlternatePort);
         }
         for (Builder.Pkp pkp : builder.publicKeyPins()) {
             nativeAddPkp(urlRequestContextConfig, pkp.mHost, pkp.mHashes, pkp.mIncludeSubdomains,
                     pkp.mExpirationDate.getTime());
         }
         return urlRequestContextConfig;
     }
@@ skipping 84 matching lines @@
         }
     }
 
     // This method is intentionally non-static to ensure Cronet native library
     // is loaded by class constructor.
     @Override
     public byte[] getGlobalMetricsDeltas() {
         return nativeGetHistogramDeltas();
     }
 
+    /**
+     * 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.
+     */
+    @Override
+    public void setRequestFinishedListenerExecutor(Executor executor) {
+        if (!mNetworkQualityEstimatorEnabled) {
+            throw new IllegalStateException("Network quality estimator not enabled");
+        }
+        if (executor == null) {
+            throw new NullPointerException("Request finished listener requires an executor");
+        }
+        if (mNetworkQualityExecutor != null) {
+            throw new NullPointerException("Request finished listener executor already set");
+        }
+        mNetworkQualityExecutor = executor;
+    }
+
+    /**
+     * TODO(tbansal):  http://crbug.com/618034 Remove this API once all
+     * embedders have switched to using CronetEngine builder for enabling
+     * network quality estimator.
+     */
     @Override
     public void enableNetworkQualityEstimator(Executor executor) {
-        enableNetworkQualityEstimatorForTesting(false, false, executor);
-    }
-
-    @VisibleForTesting
-    @Override
-    void enableNetworkQualityEstimatorForTesting(
-            boolean useLocalHostRequests, boolean useSmallerResponses, Executor executor) {
         if (mNetworkQualityEstimatorEnabled) {
             throw new IllegalStateException("Network quality estimator already enabled");
         }
         mNetworkQualityEstimatorEnabled = true;
         if (executor == null) {
             throw new NullPointerException("Network quality estimator requires an executor");
         }
         mNetworkQualityExecutor = executor;
         synchronized (mLock) {
             checkHaveAdapter();
-            nativeEnableNetworkQualityEstimator(
+            nativeEnableNetworkQualityEstimator(mUrlRequestContextAdapter);
+        }
+    }
+
+    @VisibleForTesting
+    @Override
+    void configureNetworkQualityEstimatorForTesting(
+            boolean useLocalHostRequests, boolean useSmallerResponses) {
+        if (!mNetworkQualityEstimatorEnabled) {
+            throw new IllegalStateException("Network quality estimator must be enabled");
+        }
+        synchronized (mLock) {
+            checkHaveAdapter();
+            nativeConfigureNetworkQualityEstimatorForTesting(
                     mUrlRequestContextAdapter, useLocalHostRequests, useSmallerResponses);
         }
     }
 
     @Override
     public void addRttListener(NetworkQualityRttListener listener) {
         if (!mNetworkQualityEstimatorEnabled) {
             throw new IllegalStateException("Network quality estimator must be enabled");
         }
+        if (mNetworkQualityExecutor == null && listener.getExecutor() == null) {
+            throw new IllegalStateException("Executor must not be null");
+        }
         synchronized (mNetworkQualityLock) {
             if (mRttListenerList.isEmpty()) {
                 synchronized (mLock) {
                     checkHaveAdapter();
                     nativeProvideRTTObservations(mUrlRequestContextAdapter, true);
                 }
             }
             mRttListenerList.addObserver(listener);
         }
     }
@@ skipping 39 matching lines @@
             mThroughputListenerList.removeObserver(listener);
             if (mThroughputListenerList.isEmpty()) {
                 synchronized (mLock) {
                     checkHaveAdapter();
                     nativeProvideThroughputObservations(mUrlRequestContextAdapter, false);
                 }
             }
         }
     }
 
+    /**
+     * 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.
+     */
     @Override
     public void addRequestFinishedListener(RequestFinishedListener listener) {
         if (!mNetworkQualityEstimatorEnabled) {
             throw new IllegalStateException("Network quality estimator must be enabled");
         }
+        // RequestFinishedListener does not provide its own executor.
+        if (mNetworkQualityExecutor == null) {
+            throw new IllegalStateException("Executor must not be null");
+        }
         synchronized (mNetworkQualityLock) {
             mFinishedListenerList.addObserver(listener);
         }
     }
 
+    /**
+     * TODO(tbansal):  http://crbug.com/618034 Remove this API.
+     */
     @Override
     public void removeRequestFinishedListener(RequestFinishedListener listener) {
         if (!mNetworkQualityEstimatorEnabled) {
             throw new IllegalStateException("Network quality estimator must be enabled");
         }
         synchronized (mNetworkQualityLock) {
             mFinishedListenerList.removeObserver(listener);
         }
     }
 
@@ skipping 76 matching lines @@
             mNetworkThread = Thread.currentThread();
             mInitCompleted.open();
         }
         Thread.currentThread().setName("ChromiumNet");
         Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onRttObservation(final int rttMs, final long whenMs, final int source) {
-        Runnable task = new Runnable() {
-            @Override
-            public void run() {
-                synchronized (mNetworkQualityLock) {
-                    for (NetworkQualityRttListener listener : mRttListenerList) {
+        synchronized (mNetworkQualityLock) {
+            for (final NetworkQualityRttListener listener : mRttListenerList) {
+                Runnable task = new Runnable() {
+                    @Override
+                    public void run() {
                         listener.onRttObservation(rttMs, whenMs, source);
                     }
-                }
+                };
+                // Use the executor provided by the listener. If not available,
+                // use the network quality executor.
+                // TODO(tbansal): Change this to always use the executor
+                // provided by the listener, once all embedders start providing
+                // a non-null executor.
+                Executor executor = listener.getExecutor() != null ? listener.getExecutor()

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

Why do we have this fallback in onRttObservation but not in
onThroughputObservation?

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

Same reason as I commented elsewhere: "Because, the embedders are already using
RttListener (so, I need to transition
that API in 2-steps).

Embedders are not using ThroughputListener yet, so I can change the API
abruptly."

+                                                                   : mNetworkQualityExecutor;
+                postObservationTaskToExecutor(executor, task);
             }
-        };
-        postObservationTaskToNetworkQualityExecutor(task);
+        }
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onThroughputObservation(
             final int throughputKbps, final long whenMs, final int source) {
+        synchronized (mNetworkQualityLock) {
+            for (final NetworkQualityThroughputListener listener : mThroughputListenerList) {
+                Runnable task = new Runnable() {
+                    @Override
+                    public void run() {
+                        listener.onThroughputObservation(throughputKbps, whenMs, source);
+                    }
+                };
+                postObservationTaskToExecutor(listener.getExecutor(), task);
+            }
+        }
+    }
+
+    void reportFinished(final CronetUrlRequest request) {
+        if (!mNetworkQualityEstimatorEnabled) {
+            return;
+        }
+        // If no request finished listener has been added, then mNetworkQualityExecutor may be
+        // null. Exit early to avoid posting to a null executor.
+        synchronized (mNetworkQualityLock) {
+            if (mFinishedListenerList.isEmpty()) {
+                return;
+            }
+        }
         Runnable task = new Runnable() {
             @Override
             public void run() {
                 synchronized (mNetworkQualityLock) {
-                    for (NetworkQualityThroughputListener listener : mThroughputListenerList) {
-                        listener.onThroughputObservation(throughputKbps, whenMs, source);
+                    UrlRequestInfo requestInfo = request.getRequestInfo();
+                    for (RequestFinishedListener listener : mFinishedListenerList) {
+                        listener.onRequestFinished(requestInfo);
                     }
                 }
             }
         };
-        postObservationTaskToNetworkQualityExecutor(task);
+        // Use {@link mNetworkQualityExecutor} since
+        // RequestFInishedListeners do not provide an executor.
+        postObservationTaskToExecutor(mNetworkQualityExecutor, task);
     }
 
-    void reportFinished(final CronetUrlRequest request) {
-        if (mNetworkQualityEstimatorEnabled) {
-            Runnable task = new Runnable() {
-                @Override
-                public void run() {
-                    synchronized (mNetworkQualityLock) {
-                        UrlRequestInfo requestInfo = request.getRequestInfo();
-                        for (RequestFinishedListener listener : mFinishedListenerList) {
-                            listener.onRequestFinished(requestInfo);
-                        }
-                    }
-                }
-            };
-            postObservationTaskToNetworkQualityExecutor(task);
-        }
-    }
-
-    void postObservationTaskToNetworkQualityExecutor(Runnable task) {
+    private static void postObservationTaskToExecutor(Executor executor, Runnable task) {
         try {
-            mNetworkQualityExecutor.execute(task);
+            executor.execute(task);
         } catch (RejectedExecutionException failException) {
             Log.e(CronetUrlRequestContext.LOG_TAG, "Exception posting task to executor",
                     failException);
         }
     }
 
     // Native methods are implemented in cronet_url_request_context_adapter.cc.
     private static native long nativeCreateRequestContextConfig(String userAgent,
             String storagePath, boolean quicEnabled, String quicUserAgentId, boolean http2Enabled,
             boolean sdchEnabled, String dataReductionProxyKey,
             String dataReductionProxyPrimaryProxy, String dataReductionProxyFallbackProxy,
             String dataReductionProxySecureProxyCheckUrl, boolean disableCache, int httpCacheMode,
-            long httpCacheMaxSize, String experimentalOptions, long mockCertVerifier);
+            long httpCacheMaxSize, String experimentalOptions, long mockCertVerifier,
+            boolean enableNetworkQualityEstimator);
 
     private static native void nativeAddQuicHint(
             long urlRequestContextConfig, String host, int port, int alternatePort);
 
     private static native void nativeAddPkp(long urlRequestContextConfig, String host,
             byte[][] hashes, boolean includeSubdomains, long expirationTime);
 
     private static native long nativeCreateRequestContextAdapter(long urlRequestContextConfig);
 
     private static native int nativeSetMinLogLevel(int loggingLevel);
 
     private static native byte[] nativeGetHistogramDeltas();
 
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
     private native void nativeDestroy(long nativePtr);
 
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
     private native void nativeStartNetLogToFile(long nativePtr,
             String fileName, boolean logAll);
 
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
     private native void nativeStopNetLog(long nativePtr);
 
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
     private native void nativeInitRequestContextOnMainThread(long nativePtr);
 
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
-    private native void nativeEnableNetworkQualityEstimator(
+    private native void nativeConfigureNetworkQualityEstimatorForTesting(
             long nativePtr, boolean useLocalHostRequests, boolean useSmallerResponses);
 
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
+    private native void nativeEnableNetworkQualityEstimator(long nativePtr);
+
+    @NativeClassQualifiedName("CronetURLRequestContextAdapter")
     private native void nativeProvideRTTObservations(long nativePtr, boolean should);
 
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
     private native void nativeProvideThroughputObservations(long nativePtr, boolean should);
 }