[Cronet] Hook up library loader, system proxy and network change notifier to async api.

components/cronet/android/java/src/org/chromium/net/CronetLibraryLoader.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.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+
+import org.chromium.base.JNINamespace;
+
+/**
+ * CronetLibraryLoader loads and initializes native library on main thread.
+ */
+@JNINamespace("cronet")
+class CronetLibraryLoader {
+    /**
+     * Synchronize access to sInitTaskPosted and initialization routine.
+     */
+    private static final Object sLoadLock = new Object();
+    private static boolean sInitTaskPosted = false;
+
+    /**
+     * Ensure that native library is loaded and initialized. Can be called from
+     * any thread, the load and initialization is performed on main thread.
+     */
+    public static void ensureInitialized(
+            final Context context, final UrlRequestContextConfig config) {
+        synchronized (sLoadLock) {
+            if (sInitTaskPosted) {
+                return;
+            }
+            System.loadLibrary(config.libraryName());
+            // Init native Chromium URLRequestContext on Main UI thread.
+            Runnable task = new Runnable() {
+                public void run() {
+                    initOnMainThread(context);
+                }
+            };
+            // 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);
+            }
+            sInitTaskPosted = true;
+        }
+    }
+
+    private static void initOnMainThread(final Context context) {
+        NetworkChangeNotifier.init(context);
+        // Registers to always receive network notifications. Note
+        // that this call is fine for Cronet because Cronet
+        // embedders do not have API access to create network change
+        // observers. Existing observers in the net stack do not
+        // perform expensive work.
+        NetworkChangeNotifier.registerToReceiveNotificationsAlways();
+        nativeCronetInitOnMainThread(context);

[xunjieli, 2015/02/03 18:37:59]

Maybe move nativeCronetInitOnMainThread(context) in front of
NetworkChangeNotifier.registerToReceiveNotificationsAlways() ?
Then we can get rid of NetworkChangeNotifier.init(context).

[mef, 2015/02/03 20:08:55]

I'll be glad to do that as I was just copying whatever was done before.
Should it be 

nativeCronetInitOnMainThread(context);
NetworkChangeNotifier.registerToReceiveNotificationsAlways();

without 

NetworkChangeNotifier.init(context);

[xunjieli, 2015/02/03 20:11:48]

Yes, that should do it. Thanks!

[mef, 2015/02/03 22:09:26]

Done.

[mef, 2015/02/05 19:28:56]

This change is causing first request to fail with error
net::ERR_NETWORK_CHANGED, 
so I've reverted sequence back to NCN::init ->
NCN::registerToReceiveNotifications -> CronetInit.

[xunjieli, 2015/02/05 19:47:49]

I don't understand why this happens. We post initOnMainThread task to the main
thread, we then post initialize request context to the main thread. A url
request will be delayed after request context is fully initialized. I don't see
why changing the order here will make the first request to fail with
net::ERR_NETWORK_CHANGED. Paul, any guess?

[mef, 2015/02/05 20:31:06]

Why was it originally done in this order here:
https://code.google.com/p/chromium/codesearch#chromium/src/components/cronet/...

+    }
+
+    // Native methods are implemented in cronet_loader.cc.
+    private static native long nativeCronetInitOnMainThread(Context context);
+}