[Cronet] Add callback wrapper classes to enforce API version checking.

components/cronet/android/java/src/org/chromium/net/impl/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.impl;
 
 import android.os.ConditionVariable;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Process;
@@ skipping 15 matching lines @@
 import org.chromium.net.UrlRequest;
 import org.chromium.net.urlconnection.CronetHttpURLConnection;
 import org.chromium.net.urlconnection.CronetURLStreamHandlerFactory;
 
 import java.net.Proxy;
 import java.net.URL;
 import java.net.URLConnection;
 import java.net.URLStreamHandlerFactory;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Executor;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import javax.annotation.concurrent.GuardedBy;
 
 /**
  * CronetEngine using Chromium HTTP stack implementation.
@@ skipping 62 matching lines @@
     private int mTransportRttMs = RttThroughputValues.INVALID_RTT_THROUGHPUT;
 
     /**
      * Current estimate of the downstream throughput (in kilobits per second)
      * computed by the network quality estimator.
      */
     @GuardedBy("mNetworkQualityLock")
     private int mDownstreamThroughputKbps = RttThroughputValues.INVALID_RTT_THROUGHPUT;
 
     @GuardedBy("mNetworkQualityLock")
-    private final ObserverList<NetworkQualityRttListener> mRttListenerList =
-            new ObserverList<NetworkQualityRttListener>();
+    private final ObserverList<VersionSafeCallbacks.NetworkQualityRttListenerWrapper>
+            mRttListenerList =
+                    new ObserverList<VersionSafeCallbacks.NetworkQualityRttListenerWrapper>();
 
     @GuardedBy("mNetworkQualityLock")
-    private final ObserverList<NetworkQualityThroughputListener> mThroughputListenerList =
-            new ObserverList<NetworkQualityThroughputListener>();
+    private final ObserverList<VersionSafeCallbacks.NetworkQualityThroughputListenerWrapper>
+            mThroughputListenerList =
+                    new ObserverList<VersionSafeCallbacks
+                                             .NetworkQualityThroughputListenerWrapper>();
 
     @GuardedBy("mFinishedListenerLock")
-    private final List<RequestFinishedInfo.Listener> mFinishedListenerList =
-            new ArrayList<RequestFinishedInfo.Listener>();
+    private final Map<RequestFinishedInfo.Listener,
+            VersionSafeCallbacks.RequestFinishedInfoListener> mFinishedListenerMap =
+            new HashMap<RequestFinishedInfo.Listener,
+                    VersionSafeCallbacks.RequestFinishedInfoListener>();
 
     /**
      * Synchronize access to mCertVerifierData.
      */
     private ConditionVariable mWaitGetCertVerifierDataComplete = new ConditionVariable();
 
     /** Holds CertVerifier data. */
     private String mCertVerifierData;
 
     private ConditionVariable mStopNetLogCompleted;
@@ skipping 267 matching lines @@
         if (!mNetworkQualityEstimatorEnabled) {
             throw new IllegalStateException("Network quality estimator must be enabled");
         }
         synchronized (mNetworkQualityLock) {
             if (mRttListenerList.isEmpty()) {
                 synchronized (mLock) {
                     checkHaveAdapter();
                     nativeProvideRTTObservations(mUrlRequestContextAdapter, true);
                 }
             }
-            mRttListenerList.addObserver(listener);
+            mRttListenerList.addObserver(
+                    new VersionSafeCallbacks.NetworkQualityRttListenerWrapper(listener));
         }
     }
 
     @Override
     public void removeRttListener(NetworkQualityRttListener listener) {
         if (!mNetworkQualityEstimatorEnabled) {
             throw new IllegalStateException("Network quality estimator must be enabled");
         }
         synchronized (mNetworkQualityLock) {
-            mRttListenerList.removeObserver(listener);
-            if (mRttListenerList.isEmpty()) {
-                synchronized (mLock) {
-                    checkHaveAdapter();
-                    nativeProvideRTTObservations(mUrlRequestContextAdapter, false);
+            if (mRttListenerList.removeObserver(
+                        new VersionSafeCallbacks.NetworkQualityRttListenerWrapper(listener))) {
+                if (mRttListenerList.isEmpty()) {
+                    synchronized (mLock) {
+                        checkHaveAdapter();
+                        nativeProvideRTTObservations(mUrlRequestContextAdapter, false);
+                    }
                 }
             }
         }
     }
 
     @Override
     public void addThroughputListener(NetworkQualityThroughputListener listener) {
         if (!mNetworkQualityEstimatorEnabled) {
             throw new IllegalStateException("Network quality estimator must be enabled");
         }
         synchronized (mNetworkQualityLock) {
             if (mThroughputListenerList.isEmpty()) {
                 synchronized (mLock) {
                     checkHaveAdapter();
                     nativeProvideThroughputObservations(mUrlRequestContextAdapter, true);
                 }
             }
-            mThroughputListenerList.addObserver(listener);
+            mThroughputListenerList.addObserver(
+                    new VersionSafeCallbacks.NetworkQualityThroughputListenerWrapper(listener));
         }
     }
 
     @Override
     public void removeThroughputListener(NetworkQualityThroughputListener listener) {
         if (!mNetworkQualityEstimatorEnabled) {
             throw new IllegalStateException("Network quality estimator must be enabled");
         }
         synchronized (mNetworkQualityLock) {
-            mThroughputListenerList.removeObserver(listener);
-            if (mThroughputListenerList.isEmpty()) {
-                synchronized (mLock) {
-                    checkHaveAdapter();
-                    nativeProvideThroughputObservations(mUrlRequestContextAdapter, false);
+            if (mThroughputListenerList.removeObserver(
+                        new VersionSafeCallbacks.NetworkQualityThroughputListenerWrapper(
+                                listener))) {
+                if (mThroughputListenerList.isEmpty()) {
+                    synchronized (mLock) {
+                        checkHaveAdapter();
+                        nativeProvideThroughputObservations(mUrlRequestContextAdapter, false);
+                    }
                 }
             }
         }
     }
 
     @Override
     public void addRequestFinishedListener(RequestFinishedInfo.Listener listener) {
         synchronized (mFinishedListenerLock) {
-            mFinishedListenerList.add(listener);
+            mFinishedListenerMap.put(
+                    listener, new VersionSafeCallbacks.RequestFinishedInfoListener(listener));
         }
     }
 
     @Override
     public void removeRequestFinishedListener(RequestFinishedInfo.Listener listener) {
         synchronized (mFinishedListenerLock) {
-            mFinishedListenerList.remove(listener);
+            mFinishedListenerMap.remove(listener);
         }
     }
 
     boolean hasRequestFinishedListener() {
         synchronized (mFinishedListenerLock) {
-            return !mFinishedListenerList.isEmpty();
+            return !mFinishedListenerMap.isEmpty();
         }
     }
 
     @Override
     public URLConnection openConnection(URL url) {
         return openConnection(url, Proxy.NO_PROXY);
     }
 
     @Override
     public URLConnection openConnection(URL url, Proxy proxy) {
@@ skipping 112 matching lines @@
             mHttpRttMs = httpRttMs;
             mTransportRttMs = transportRttMs;
             mDownstreamThroughputKbps = downstreamThroughputKbps;
         }
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onRttObservation(final int rttMs, final long whenMs, final int source) {
         synchronized (mNetworkQualityLock) {
-            for (final NetworkQualityRttListener listener : mRttListenerList) {
+            for (final VersionSafeCallbacks.NetworkQualityRttListenerWrapper listener :
+                    mRttListenerList) {
                 Runnable task = new Runnable() {
                     @Override
                     public void run() {
                         listener.onRttObservation(rttMs, whenMs, source);
                     }
                 };
                 postObservationTaskToExecutor(listener.getExecutor(), task);
             }
         }
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onThroughputObservation(
             final int throughputKbps, final long whenMs, final int source) {
         synchronized (mNetworkQualityLock) {
-            for (final NetworkQualityThroughputListener listener : mThroughputListenerList) {
+            for (final VersionSafeCallbacks.NetworkQualityThroughputListenerWrapper listener :
+                    mThroughputListenerList) {
                 Runnable task = new Runnable() {
                     @Override
                     public void run() {
                         listener.onThroughputObservation(throughputKbps, whenMs, source);
                     }
                 };
                 postObservationTaskToExecutor(listener.getExecutor(), task);
             }
         }
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onGetCertVerifierData(String certVerifierData) {
         mCertVerifierData = certVerifierData;
         mWaitGetCertVerifierDataComplete.open();
     }
 
     void reportFinished(final RequestFinishedInfo requestInfo) {
-        ArrayList<RequestFinishedInfo.Listener> currentListeners;
+        ArrayList<VersionSafeCallbacks.RequestFinishedInfoListener> currentListeners;
         synchronized (mFinishedListenerLock) {
-            currentListeners = new ArrayList<RequestFinishedInfo.Listener>(mFinishedListenerList);
+            currentListeners = new ArrayList<VersionSafeCallbacks.RequestFinishedInfoListener>(
+                    mFinishedListenerMap.values());
         }
-        for (final RequestFinishedInfo.Listener listener : currentListeners) {
+        for (final VersionSafeCallbacks.RequestFinishedInfoListener listener : currentListeners) {
             Runnable task = new Runnable() {
                 @Override
                 public void run() {
                     listener.onRequestFinished(requestInfo);
                 }
             };
             postObservationTaskToExecutor(listener.getExecutor(), task);
         }
     }
 
@@ skipping 54 matching lines @@
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
     private native void nativeProvideRTTObservations(long nativePtr, boolean should);
 
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
     private native void nativeProvideThroughputObservations(long nativePtr, boolean should);
 
     public boolean isNetworkThread(Thread thread) {
         return thread == mNetworkThread;
     }
 }