[Cronet] Move initialization to a new thread rather than the UI thread.

The UI thread is generally overbooked (esp at app startup time) so
avoiding it can greatly improve Cronet startup time.  The UI thread
was used for initialization previously because it simplified the
NetworkChangeNotifierAutoDetect and ProxyChangeListener logic because
BroadcastReceiver onReceived callbacks always happen on the UI thread
so those classes could be completely single-threaded.  This change
leaves those classes single-threaded except for their onRecieved()
methods which now immediately post to the new initialization thread
and check whether their BroadcastReceivers are currently registered.

BUG=709336
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.android:android_cronet_tester

Review-Url: https://codereview.chromium.org/2812963002
Cr-Commit-Position: refs/heads/master@{#469578}

components/cronet/android/cronet_library_loader.cc

@@ -53,9 +53,9 @@ const base::android::RegistrationMethod kCronetRegisteredMethods[] = {
     {"NetAndroid", net::android::RegisterJni},
 };
 
-// MessageLoop on the main thread, which is where objects that receive Java
+// MessageLoop on the init thread, which is where objects that receive Java
 // notifications generally live.
-base::MessageLoop* g_main_message_loop = nullptr;
+base::MessageLoop* g_init_message_loop = nullptr;
 
 net::NetworkChangeNotifier* g_network_change_notifier = nullptr;
 
@@ -76,6 +76,11 @@ bool NativeInit() {
 
 }  // namespace
 
+bool OnInitThread() {
+  DCHECK(g_init_message_loop);
+  return g_init_message_loop == base::MessageLoop::current();
+}
+
 // Checks the available version of JNI. Also, caches Java reflection artifacts.
 jint CronetOnLoad(JavaVM* vm, void* reserved) {
   base::android::InitVM(vm);
@@ -91,7 +96,7 @@ void CronetOnUnLoad(JavaVM* jvm, void* reserved) {
   base::android::LibraryLoaderExitHook();
 }
 
-void CronetInitOnMainThread(JNIEnv* env, const JavaParamRef<jclass>& jcaller) {
+void CronetInitOnInitThread(JNIEnv* env, const JavaParamRef<jclass>& jcaller) {
 #if !BUILDFLAG(USE_PLATFORM_ICU_ALTERNATIVES)
   base::i18n::InitializeICU();
 #endif
@@ -101,9 +106,8 @@ void CronetInitOnMainThread(JNIEnv* env, const JavaParamRef<jclass>& jcaller) {
   // configuration information.
   base::CommandLine::Init(0, nullptr);
   DCHECK(!base::MessageLoop::current());
-  DCHECK(!g_main_message_loop);
-  g_main_message_loop = new base::MessageLoopForUI();
-  base::MessageLoopForUI::current()->Start();
+  DCHECK(!g_init_message_loop);
+  g_init_message_loop = new base::MessageLoop();
   DCHECK(!g_network_change_notifier);
   net::NetworkChangeNotifier::SetFactory(
       new net::NetworkChangeNotifierFactoryAndroid());

components/cronet/android/cronet_library_loader.h

@@ -12,6 +12,10 @@ namespace cronet {
 jint CronetOnLoad(JavaVM* vm, void* reserved);
 void CronetOnUnLoad(JavaVM* jvm, void* reserved);
 
+// Returns true when running on initialization thread.
+// Only callable after initialization thread is started.
+bool OnInitThread();
+
 }  // namespace cronet
 
 #endif  // COMPONENTS_CRONET_ANDROID_CRONET_LIBRARY_LOADER_H_

components/cronet/android/cronet_url_request_context_adapter.cc

@@ -37,6 +37,7 @@
 #include "base/values.h"
 #include "components/cronet/android/cert/cert_verifier_cache_serializer.h"
 #include "components/cronet/android/cert/proto/cert_verification.pb.h"
+#include "components/cronet/android/cronet_library_loader.h"
 #include "components/cronet/histogram_manager.h"
 #include "components/cronet/url_request_context_config.h"
 #include "components/prefs/pref_change_registrar.h"
@@ -84,16 +85,16 @@ class NetLogWithNetworkChangeEvents {
   net::NetLog* net_log() { return &net_log_; }
   // This function registers with the NetworkChangeNotifier and so must be
   // called *after* the NetworkChangeNotifier is created. Should only be
-  // called on the UI thread as it is not thread-safe and the UI thread is
+  // called on the init thread as it is not thread-safe and the init thread is
   // the thread the NetworkChangeNotifier is created on. This function is
   // not thread-safe because accesses to |net_change_logger_| are not atomic.
   // There might be multiple CronetEngines each with a network thread so
-  // so the UI thread is used. |g_net_log_| also outlives the network threads
+  // so the init thread is used. |g_net_log_| also outlives the network threads
   // so it would be unsafe to receive callbacks on the network threads without
   // a complicated thread-safe reference-counting system to control callback
   // registration.
-  void EnsureInitializedOnMainThread() {
-    DCHECK(base::MessageLoopForUI::IsCurrent());
+  void EnsureInitializedOnInitThread() {
+    DCHECK(cronet::OnInitThread());
     if (net_change_logger_)
       return;
     net_change_logger_.reset(new net::LoggingNetworkChangeObserver(&net_log_));
@@ -504,7 +505,7 @@ CronetURLRequestContextAdapter::~CronetURLRequestContextAdapter() {
   StopNetLogOnNetworkThread();
 }
 
-void CronetURLRequestContextAdapter::InitRequestContextOnMainThread(
+void CronetURLRequestContextAdapter::InitRequestContextOnInitThread(
     JNIEnv* env,
     const JavaParamRef<jobject>& jcaller) {
   base::android::ScopedJavaGlobalRef<jobject> jcaller_ref;
@@ -518,7 +519,7 @@ void CronetURLRequestContextAdapter::InitRequestContextOnMainThread(
   // TODO(csharrison) Architect the wrapper better so we don't need to cast for
   // android ProxyConfigServices.
   android_proxy_config_service->set_exclude_pac_url(true);
-  g_net_log.Get().EnsureInitializedOnMainThread();
+  g_net_log.Get().EnsureInitializedOnInitThread();
   GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&CronetURLRequestContextAdapter::InitializeOnNetworkThread,

components/cronet/android/cronet_url_request_context_adapter.h

@@ -58,8 +58,8 @@ class CronetURLRequestContextAdapter
 
   ~CronetURLRequestContextAdapter() override;
 
-  // Called on main Java thread to initialize URLRequestContext.
-  void InitRequestContextOnMainThread(
+  // Called on init Java thread to initialize URLRequestContext.
+  void InitRequestContextOnInitThread(
       JNIEnv* env,
       const base::android::JavaParamRef<jobject>& jcaller);
 
@@ -107,8 +107,8 @@ class CronetURLRequestContextAdapter
   // Default net::LOAD flags used to create requests.
   int default_load_flags() const { return default_load_flags_; }
 
-  // Called on main Java thread to initialize URLRequestContext.
-  void InitRequestContextOnMainThread();
+  // Called on init Java thread to initialize URLRequestContext.
+  void InitRequestContextOnInitThread();
 
   // Configures the network quality estimator to observe requests to localhost,
   // to use smaller responses when estimating throughput, and to disable the

components/cronet/android/java/src/org/chromium/net/impl/CronetLibraryLoader.java

@@ -6,6 +6,7 @@ package org.chromium.net.impl;
 
 import android.content.Context;
 import android.os.Handler;
+import android.os.HandlerThread;
 import android.os.Looper;
 
 import org.chromium.base.ContextUtils;
@@ -15,7 +16,7 @@ import org.chromium.base.annotations.JNINamespace;
 import org.chromium.net.NetworkChangeNotifier;
 
 /**
- * CronetLibraryLoader loads and initializes native library on main thread.
+ * CronetLibraryLoader loads and initializes native library on init thread.
  */
 @JNINamespace("cronet")
 @VisibleForTesting
@@ -24,14 +25,18 @@ public class CronetLibraryLoader {
     private static final Object sLoadLock = new Object();
     private static final String LIBRARY_NAME = "cronet." + ImplVersion.getCronetVersion();
     private static final String TAG = CronetLibraryLoader.class.getSimpleName();
+    // Thread used for initialization work and processing callbacks for
+    // long-lived global singletons. This thread lives forever as things like
+    // the global singleton NetworkChangeNotifier live on it and are never killed.
+    private static final HandlerThread sInitThread = new HandlerThread("CronetInit");
     // Has library loading commenced?  Setting guarded by sLoadLock.
     private static volatile boolean sLibraryLoaded = false;
-    // Has ensureMainThreadInitialized() completed?  Only accessed on main thread.
-    private static volatile boolean sMainThreadInitDone = false;
+    // Has ensureInitThreadInitialized() completed?
+    private static volatile boolean sInitThreadInitDone = false;
 
     /**
      * Ensure that native library is loaded and initialized. Can be called from
-     * any thread, the load and initialization is performed on main thread.
+     * any thread, the load and initialization is performed on init thread.
      */
     public static void ensureInitialized(
             final Context applicationContext, final CronetEngineBuilderImpl builder) {
@@ -55,35 +60,36 @@ public class CronetLibraryLoader {
                 sLibraryLoaded = true;
             }
 
-            if (!sMainThreadInitDone) {
-                // Init native Chromium CronetEngine on Main UI thread.
-                Runnable task = new Runnable() {
+            if (!sInitThreadInitDone) {
+                if (!sInitThread.isAlive()) {
+                    sInitThread.start();
+                }
+                postToInitThread(new Runnable() {
                     @Override
                     public void run() {
-                        ensureInitializedOnMainThread(applicationContext);
+                        ensureInitializedOnInitThread(applicationContext);
                     }
-                };
-                // Run task immediately or post it to the UI thread.
-                if (Looper.getMainLooper() == Looper.myLooper()) {
-                    task.run();
-                } else {
-                    // The initOnMainThread will complete on the main thread prior
-                    // to other tasks posted to the main thread.
-                    new Handler(Looper.getMainLooper()).post(task);
-                }
+                });
             }
         }
     }
 
     /**
-     * Ensure that the main thread initialization has completed. Can only be called from
-     * the main thread. Ensures that the NetworkChangeNotifier is initialzied and the
-     * main thread native MessageLoop is initialized.
+     * Returns {@code true} if running on the initialization thread.
+     */
+    private static boolean onInitThread() {
+        return sInitThread.getLooper() == Looper.myLooper();
+    }
+
+    /**
+     * Ensure that the init thread initialization has completed. Can only be called from
+     * the init thread. Ensures that the NetworkChangeNotifier is initialzied and the
+     * init thread native MessageLoop is initialized.
      */
-    static void ensureInitializedOnMainThread(Context context) {
+    static void ensureInitializedOnInitThread(Context context) {
         assert sLibraryLoaded;
-        assert Looper.getMainLooper() == Looper.myLooper();
-        if (sMainThreadInitDone) {
+        assert onInitThread();
+        if (sInitThreadInitDone) {
             return;
         }
         NetworkChangeNotifier.init(context);
@@ -97,11 +103,22 @@ public class CronetLibraryLoader {
         // NetworkChangeNotifierAndroid is created, so as to avoid receiving
         // the undesired initial network change observer notification, which
         // will cause active requests to fail with ERR_NETWORK_CHANGED.
-        nativeCronetInitOnMainThread();
-        sMainThreadInitDone = true;
+        nativeCronetInitOnInitThread();
+        sInitThreadInitDone = true;
+    }
+
+    /**
+     * Run {@code r} on the initialization thread.
+     */
+    static void postToInitThread(Runnable r) {
+        if (onInitThread()) {
+            r.run();
+        } else {
+            new Handler(sInitThread.getLooper()).post(r);
+        }
     }
 
     // Native methods are implemented in cronet_library_loader.cc.
-    private static native void nativeCronetInitOnMainThread();
+    private static native void nativeCronetInitOnInitThread();
     private static native String nativeGetCronetVersion();
 }

components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequestContext.java

@@ -5,8 +5,6 @@
 package org.chromium.net.impl;
 
 import android.os.ConditionVariable;
-import android.os.Handler;
-import android.os.Looper;
 import android.os.Process;
 
 import org.chromium.base.Log;
@@ -161,25 +159,19 @@ public class CronetUrlRequestContext extends CronetEngineBase {
             mNetworkQualityEstimatorEnabled = builder.networkQualityEstimatorEnabled();
         }
 
-        // Init native Chromium URLRequestContext on main UI thread.
-        Runnable task = new Runnable() {
+        // Init native Chromium URLRequestContext on init thread.
+        CronetLibraryLoader.postToInitThread(new Runnable() {
             @Override
             public void run() {
-                CronetLibraryLoader.ensureInitializedOnMainThread(builder.getContext());
+                CronetLibraryLoader.ensureInitializedOnInitThread(builder.getContext());
                 synchronized (mLock) {
                     // mUrlRequestContextAdapter is guaranteed to exist until
-                    // initialization on main and network threads completes and
+                    // initialization on init and network threads completes and
                     // initNetworkThread is called back on network thread.
-                    nativeInitRequestContextOnMainThread(mUrlRequestContextAdapter);
+                    nativeInitRequestContextOnInitThread(mUrlRequestContextAdapter);
                 }
             }
-        };
-        // Run task immediately or post it to the UI thread.
-        if (Looper.getMainLooper() == Looper.myLooper()) {
-            task.run();
-        } else {
-            new Handler(Looper.getMainLooper()).post(task);
-        }
+        });
     }
 
     @VisibleForTesting
@@ -251,7 +243,7 @@ public class CronetUrlRequestContext extends CronetEngineBase {
                 throw new IllegalThreadStateException("Cannot shutdown from network thread.");
             }
         }
-        // Wait for init to complete on main and network thread (without lock,
+        // Wait for init to complete on init and network thread (without lock,
         // so other thread could access it).
         mInitCompleted.block();
 
@@ -711,7 +703,7 @@ public class CronetUrlRequestContext extends CronetEngineBase {
     private native void nativeGetCertVerifierData(long nativePtr);
 
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
-    private native void nativeInitRequestContextOnMainThread(long nativePtr);
+    private native void nativeInitRequestContextOnInitThread(long nativePtr);
 
     @NativeClassQualifiedName("CronetURLRequestContextAdapter")
     private native void nativeConfigureNetworkQualityEstimatorForTesting(long nativePtr,

net/BUILD.gn

@@ -2984,6 +2984,7 @@ if (is_android) {
     sources = [
       "android/javatests/src/org/chromium/net/AndroidKeyStoreTestUtil.java",
       "android/javatests/src/org/chromium/net/AndroidNetworkLibraryTestUtil.java",
+      "android/javatests/src/org/chromium/net/AndroidProxyConfigServiceTestUtil.java",
       "test/android/javatests/src/org/chromium/net/test/DummySpnegoAuthenticator.java",
       "test/android/javatests/src/org/chromium/net/test/EmbeddedTestServerImpl.java",
     ]

net/android/BUILD.gn

@@ -115,6 +115,7 @@ android_library("net_javatests") {
   java_files = [
     "javatests/src/org/chromium/net/AndroidKeyStoreTestUtil.java",
     "javatests/src/org/chromium/net/AndroidNetworkLibraryTestUtil.java",
+    "javatests/src/org/chromium/net/AndroidProxyConfigServiceTestUtil.java",
     "javatests/src/org/chromium/net/AndroidProxySelectorTest.java",
     "javatests/src/org/chromium/net/NetErrorsTest.java",
     "javatests/src/org/chromium/net/NetworkChangeNotifierTest.java",

net/android/java/src/org/chromium/net/NetworkChangeNotifierAutoDetect.java

@@ -26,12 +26,14 @@ import android.net.NetworkRequest;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
 import android.telephony.TelephonyManager;
 
 import org.chromium.base.ApplicationState;
 import org.chromium.base.ApplicationStatus;
+import org.chromium.base.BuildConfig;
 import org.chromium.base.ContextUtils;
-import org.chromium.base.ThreadUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.metrics.RecordHistogram;
 
@@ -367,7 +369,7 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
         }
 
         String getWifiSsid() {
-            // Synchronized because this method can be called on multiple threads (e.g. UI thread
+            // Synchronized because this method can be called on multiple threads (e.g. mLooper
             // from a private caller, and another thread calling a public API like
             // getCurrentNetworkState) and is otherwise racy.
             synchronized (mLock) {
@@ -409,7 +411,7 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
     // This class gets called back by ConnectivityManager whenever networks come
     // and go. It gets called back on a special handler thread
     // ConnectivityManager creates for making the callbacks. The callbacks in
-    // turn post to the UI thread where mObserver lives.
+    // turn post to mLooper where mObserver lives.
     @TargetApi(Build.VERSION_CODES.LOLLIPOP)
     private class MyNetworkCallback extends NetworkCallback {
         // If non-null, this indicates a VPN is in place for the current user, and no other
@@ -484,7 +486,7 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
             final long netId = networkToNetId(network);
             @ConnectionType
             final int connectionType = mConnectivityManagerDelegate.getConnectionType(network);
-            ThreadUtils.postOnUiThread(new Runnable() {
+            runOnThread(new Runnable() {
                 @Override
                 public void run() {
                     mObserver.onNetworkConnect(netId, connectionType);
@@ -508,7 +510,7 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
             // so forward the new ConnectionType along to observer.
             final long netId = networkToNetId(network);
             final int connectionType = mConnectivityManagerDelegate.getConnectionType(network);
-            ThreadUtils.postOnUiThread(new Runnable() {
+            runOnThread(new Runnable() {
                 @Override
                 public void run() {
                     mObserver.onNetworkConnect(netId, connectionType);
@@ -522,7 +524,7 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
                 return;
             }
             final long netId = networkToNetId(network);
-            ThreadUtils.postOnUiThread(new Runnable() {
+            runOnThread(new Runnable() {
                 @Override
                 public void run() {
                     mObserver.onNetworkSoonToDisconnect(netId);
@@ -535,7 +537,7 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
             if (ignoreNetworkDueToVpn(network)) {
                 return;
             }
-            ThreadUtils.postOnUiThread(new Runnable() {
+            runOnThread(new Runnable() {
                 @Override
                 public void run() {
                     mObserver.onNetworkDisconnect(networkToNetId(network));
@@ -553,7 +555,7 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
                 }
                 @ConnectionType
                 final int newConnectionType = convertToConnectionType(getCurrentNetworkState());
-                ThreadUtils.postOnUiThread(new Runnable() {
+                runOnThread(new Runnable() {
                     @Override
                     public void run() {
                         mObserver.onConnectionTypeChanged(newConnectionType);
@@ -597,10 +599,16 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
         protected abstract void destroy();
     }
 
-    private static final String TAG = "NetworkChangeNotifierAutoDetect";
+    private static final String TAG = NetworkChangeNotifierAutoDetect.class.getSimpleName();
     private static final int UNKNOWN_LINK_SPEED = -1;
 
+    // {@link Looper} for the thread this object lives on.
+    private final Looper mLooper;
+    // Used to post to the thread this object lives on.
+    private final Handler mHandler;
+    // {@link IntentFilter} for incoming global broadcast {@link Intent}s this object listens for.
     private final NetworkConnectivityIntentFilter mIntentFilter;
+    // Notifications are sent to this {@link Observer}.
     private final Observer mObserver;
     private final RegistrationPolicy mRegistrationPolicy;
 
@@ -675,16 +683,17 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
     }
 
     /**
-     * Constructs a NetworkChangeNotifierAutoDetect. Should only be called on UI thread.
+     * Constructs a NetworkChangeNotifierAutoDetect.  Lives on calling thread, receives broadcast
+     * notifications on the UI thread and forwards the notifications to be processed on the calling
+     * thread.
      * @param policy The RegistrationPolicy which determines when this class should watch
      *     for network changes (e.g. see (@link RegistrationPolicyAlwaysRegister} and
      *     {@link RegistrationPolicyApplicationStatus}).
      */
     @TargetApi(Build.VERSION_CODES.LOLLIPOP)
     public NetworkChangeNotifierAutoDetect(Observer observer, RegistrationPolicy policy) {
-        // Since BroadcastReceiver is always called back on UI thread, ensure
-        // running on UI thread so notification logic can be single-threaded.
-        ThreadUtils.assertOnUiThread();
+        mLooper = Looper.myLooper();
+        mHandler = new Handler(mLooper);
         mObserver = observer;
         mConnectivityManagerDelegate =
                 new ConnectivityManagerDelegate(ContextUtils.getApplicationContext());
@@ -713,6 +722,25 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
         mShouldSignalObserver = true;
     }
 
+    private boolean onThread() {
+        return mLooper == Looper.myLooper();
+    }
+
+    private void assertOnThread() {
+        if (BuildConfig.DCHECK_IS_ON && !onThread()) {
+            throw new IllegalStateException(
+                    "Must be called on NetworkChangeNotifierAutoDetect thread.");
+        }
+    }
+
+    private void runOnThread(Runnable r) {
+        if (onThread()) {
+            r.run();
+        } else {
+            mHandler.post(r);
+        }
+    }
+
     /**
      * Allows overriding the ConnectivityManagerDelegate for tests.
      */
@@ -741,6 +769,7 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
     }
 
     public void destroy() {
+        assertOnThread();
         mRegistrationPolicy.destroy();
         unregister();
     }
@@ -749,7 +778,7 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
      * Registers a BroadcastReceiver in the given context.
      */
     public void register() {
-        ThreadUtils.assertOnUiThread();
+        assertOnThread();
         if (mRegistered) return;
 
         if (mShouldSignalObserver) {
@@ -790,6 +819,7 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
      * Unregisters a BroadcastReceiver in the given context.
      */
     public void unregister() {
+        assertOnThread();
         if (!mRegistered) return;
         ContextUtils.getApplicationContext().unregisterReceiver(this);
         mRegistered = false;
@@ -997,15 +1027,23 @@ public class NetworkChangeNotifierAutoDetect extends BroadcastReceiver {
     // BroadcastReceiver
     @Override
     public void onReceive(Context context, Intent intent) {
-        if (mIgnoreNextBroadcast) {
-            mIgnoreNextBroadcast = false;
-            return;
-        }
-        final NetworkState networkState = getCurrentNetworkState();
-        if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
-            connectionTypeChanged(networkState);
-            maxBandwidthChanged(networkState);
-        }
+        runOnThread(new Runnable() {
+            @Override
+            public void run() {
+                // Once execution begins on the correct thread, make sure unregister() hasn't
+                // been called in the mean time. Ignore the broadcast if unregister() was called.
+                if (!mRegistered) {
+                    return;
+                }
+                if (mIgnoreNextBroadcast) {
+                    mIgnoreNextBroadcast = false;
+                    return;
+                }
+                final NetworkState networkState = getCurrentNetworkState();
+                connectionTypeChanged(networkState);
+                maxBandwidthChanged(networkState);
+            }
+        });
     }
 
     private void connectionTypeChanged(NetworkState networkState) {

net/android/java/src/org/chromium/net/ProxyChangeListener.java

@@ -11,9 +11,12 @@ import android.content.IntentFilter;
 import android.net.Proxy;
 import android.net.Uri;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
 import android.text.TextUtils;
 import android.util.Log;
 
+import org.chromium.base.BuildConfig;
 import org.chromium.base.ContextUtils;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
@@ -31,6 +34,9 @@ public class ProxyChangeListener {
     private static final String TAG = "ProxyChangeListener";
     private static boolean sEnabled = true;
 
+    private final Looper mLooper;
+    private final Handler mHandler;
+
     private long mNativePtr;
     private ProxyReceiver mProxyReceiver;
     private Delegate mDelegate;
@@ -55,7 +61,10 @@ public class ProxyChangeListener {
         public void proxySettingsChanged();
     }
 
-    private ProxyChangeListener() {}
+    private ProxyChangeListener() {
+        mLooper = Looper.myLooper();
+        mHandler = new Handler(mLooper);
+    }
 
     public static void setEnabled(boolean enabled) {
         sEnabled = enabled;
@@ -77,6 +86,7 @@ public class ProxyChangeListener {
 
     @CalledByNative
     public void start(long nativePtr) {
+        assertOnThread();
         assert mNativePtr == 0;
         mNativePtr = nativePtr;
         registerReceiver();
@@ -84,15 +94,21 @@ public class ProxyChangeListener {
 
     @CalledByNative
     public void stop() {
+        assertOnThread();
         mNativePtr = 0;
         unregisterReceiver();
     }
 
     private class ProxyReceiver extends BroadcastReceiver {
         @Override
-        public void onReceive(Context context, Intent intent) {
+        public void onReceive(Context context, final Intent intent) {
             if (intent.getAction().equals(Proxy.PROXY_CHANGE_ACTION)) {
-                proxySettingsChanged(extractNewProxy(intent));
+                runOnThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        proxySettingsChanged(ProxyReceiver.this, extractNewProxy(intent));
+                    }
+                });
             }
         }
 
@@ -173,8 +189,12 @@ public class ProxyChangeListener {
         }
     }
 
-    private void proxySettingsChanged(ProxyConfig cfg) {
-        if (!sEnabled) {
+    private void proxySettingsChanged(ProxyReceiver proxyReceiver, ProxyConfig cfg) {
+        if (!sEnabled
+                // Once execution begins on the correct thread, make sure unregisterReceiver()
+                // hasn't been called in the mean time. Ignore the changed signal if
+                // unregisterReceiver() was called.
+                || proxyReceiver != mProxyReceiver) {
             return;
         }
         if (mDelegate != null) {
@@ -211,6 +231,24 @@ public class ProxyChangeListener {
         mProxyReceiver = null;
     }
 
+    private boolean onThread() {
+        return mLooper == Looper.myLooper();
+    }
+
+    private void assertOnThread() {
+        if (BuildConfig.DCHECK_IS_ON && !onThread()) {
+            throw new IllegalStateException("Must be called on ProxyChangeListener thread.");
+        }
+    }
+
+    private void runOnThread(Runnable r) {
+        if (onThread()) {
+            r.run();
+        } else {
+            mHandler.post(r);
+        }
+    }
+
     /**
      * See net/proxy/proxy_config_service_android.cc
      */

net/android/javatests/src/org/chromium/net/AndroidProxyConfigServiceTestUtil.java

+// Copyright 2017 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.os.Looper;
+
+import org.chromium.base.annotations.CalledByNative;
+
+/**
+ * Utility functions for testing features implemented in ProxyConfigServiceAndroid.
+ */
+public class AndroidProxyConfigServiceTestUtil {
+    /**
+     * Helper for tests that prepares the Looper on the current thread.
+     */
+    @CalledByNative
+    private static void prepareLooper() {
+        Looper.prepare();
+    }
+}
\ No newline at end of file

net/android/javatests/src/org/chromium/net/NetworkChangeNotifierTest.java

@@ -592,6 +592,7 @@ public class NetworkChangeNotifierTest {
     @MediumTest
     @Feature({"Android-AppBase"})
     public void testNetworkChangeNotifierJavaObservers() {
+        mReceiver.register();
         // Initialize the NetworkChangeNotifier with a connection.
         Intent connectivityIntent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION);
         mReceiver.onReceive(InstrumentationRegistry.getInstrumentation().getTargetContext(),
@@ -657,6 +658,7 @@ public class NetworkChangeNotifierTest {
     @MediumTest
     @Feature({"Android-AppBase"})
     public void testNetworkChangeNotifierMaxBandwidthNotifications() {
+        mReceiver.register();
         // Initialize the NetworkChangeNotifier with a connection.
         mConnectivityDelegate.setActiveNetworkExists(true);
         mConnectivityDelegate.setNetworkType(ConnectivityManager.TYPE_WIFI);
@@ -953,6 +955,7 @@ public class NetworkChangeNotifierTest {
     @MediumTest
     @Feature({"Android-AppBase"})
     public void testNetworkChangeNotifierIsOnline() {
+        mReceiver.register();
         Intent intent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION);
         // For any connection type it should return true.
         for (int i = ConnectivityManager.TYPE_MOBILE; i < ConnectivityManager.TYPE_VPN; i++) {

net/proxy/proxy_config_service_android_unittest.cc

@@ -12,6 +12,7 @@
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "jni/AndroidProxyConfigServiceTestUtil_jni.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -45,6 +46,15 @@ class TestObserver : public ProxyConfigService::Observer {
   ProxyConfigService::ConfigAvailability availability_;
 };
 
+// Helper class that simply prepares Java's Looper on construction.
+class JavaLooperPreparer {
+ public:
+  JavaLooperPreparer() {
+    Java_AndroidProxyConfigServiceTestUtil_prepareLooper(
+        base::android::AttachCurrentThread());
+  }
+};
+
 }  // namespace
 
 typedef std::map<std::string, std::string> StringMap;
@@ -104,6 +114,10 @@ class ProxyConfigServiceAndroidTestBase : public testing::Test {
   StringMap configuration_;
   TestObserver observer_;
   base::MessageLoop* const message_loop_;
+  // |java_looper_preparer_| appears before |service_| so that Java's Looper is
+  // prepared before constructing |service_| as it creates a ProxyChangeListener
+  // which requires a Looper.
+  JavaLooperPreparer java_looper_preparer_;
   ProxyConfigServiceAndroid service_;
 };