Remove app context init from LibraryLoader.

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

 // Copyright 2012 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 static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET;
 import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
 import static android.net.NetworkCapabilities.TRANSPORT_VPN;
 import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
@@ skipping 126 matching lines @@
              * @param vpnAccessible Is this VPN accessible to the current user?
              */
             MockNetwork(int netId, int transport, boolean vpnAccessible) {
                 mNetId = netId;
                 mTransport = transport;
                 mVpnAccessible = vpnAccessible;
             }
         }
 
         // List of networks we're pretending are currently connected.
-        private final ArrayList<MockNetwork> mMockNetworks = new ArrayList<MockNetwork>();
+        private final ArrayList<MockNetwork> mMockNetworks = new ArrayList<>();
 
         private boolean mActiveNetworkExists;
         private int mNetworkType;
         private int mNetworkSubtype;
         private NetworkCallback mLastRegisteredNetworkCallback;
 
         @Override
         public NetworkState getNetworkState() {
             return new NetworkState(mActiveNetworkExists, mNetworkType, mNetworkSubtype);
         }
@@ skipping 139 matching lines @@
             mChangeType = changeType;
             mNetId = demungeNetId(netId);
         }
     }
 
     // NetworkChangeNotifierAutoDetect.Observer used to verify proper notifications are sent out.
     // Notifications come back on UI thread. assertLastChange() called on test thread.
     private static class TestNetworkChangeNotifierAutoDetectObserver
             implements NetworkChangeNotifierAutoDetect.Observer {
         // The list of network changes that have been witnessed.
-        final ArrayList<ChangeInfo> mChanges = new ArrayList<ChangeInfo>();
+        final ArrayList<ChangeInfo> mChanges = new ArrayList<>();
 
         @Override
         public void onConnectionTypeChanged(int newConnectionType) {}
         @Override
         public void onMaxBandwidthChanged(double maxBandwidthMbps) {}
 
         @Override
         public void onNetworkConnect(long netId, int connectionType) {
             ThreadUtils.assertOnUiThread();
             mChanges.add(new ChangeInfo(ChangeType.CONNECT, netId));
@@ skipping 88 matching lines @@
         try {
             return mNetworkConstructor.newInstance(netId);
         } catch (InstantiationException | InvocationTargetException | IllegalAccessException e) {
             throw new IllegalStateException("Trying to create Network when not allowed");
         }
     }
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-        LibraryLoader.get(LibraryProcessType.PROCESS_BROWSER)
-                .ensureInitialized(getInstrumentation().getTargetContext());
+        LibraryLoader.get(LibraryProcessType.PROCESS_BROWSER).ensureInitialized();
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
             // Find Network.Network(int netId) using reflection.
             mNetworkConstructor = Network.class.getConstructor(Integer.TYPE);
         }
         ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
             public void run() {
                 createTestNotifier(WatchForChanges.ONLY_WHEN_APP_IN_FOREGROUND);
             }
         });
     }
 
     /**
      * Tests that the receiver registers for connectivity
      * broadcasts during construction when the registration policy dictates.
      */
@@ skipping 339 matching lines @@
     public void testNetworkCallbacks() throws Exception {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
             return;
         }
         // Setup NetworkChangeNotifierAutoDetect
         final Context context = getInstrumentation().getTargetContext();
         final TestNetworkChangeNotifierAutoDetectObserver observer =
                 new TestNetworkChangeNotifierAutoDetectObserver();
         Callable<NetworkChangeNotifierAutoDetect> callable =
                 new Callable<NetworkChangeNotifierAutoDetect>() {
+                    @Override
                     public NetworkChangeNotifierAutoDetect call() {
                         return new NetworkChangeNotifierAutoDetect(
                                 observer, context, new RegistrationPolicyApplicationStatus() {
                                     // This override prevents NetworkChangeNotifierAutoDetect from
                                     // registering for events right off the bat. We'll delay this
                                     // until our MockConnectivityManagerDelegate is first installed
                                     // to prevent inadvertent communication with the real
                                     // ConnectivityManager.
                                     @Override
                                     int getApplicationState() {
                                         return ApplicationState.HAS_PAUSED_ACTIVITIES;
                                     }
                                 });
                     }
                 };
-        FutureTask<NetworkChangeNotifierAutoDetect> task =
-                new FutureTask<NetworkChangeNotifierAutoDetect>(callable);
+        FutureTask<NetworkChangeNotifierAutoDetect> task = new FutureTask<>(callable);
         ThreadUtils.postOnUiThread(task);
         NetworkChangeNotifierAutoDetect ncn = task.get();
 
         // Insert mock ConnectivityDelegate
         mConnectivityDelegate = new MockConnectivityManagerDelegate();
         ncn.setConnectivityManagerDelegateForTests(mConnectivityDelegate);
         // Now that mock ConnectivityDelegate is inserted, pretend app is foregrounded
         // so NetworkChangeNotifierAutoDetect will register its NetworkCallback.
         assertFalse(ncn.isReceiverRegisteredForTesting());
 
@@ skipping 86 matching lines @@
             mConnectivityDelegate.setActiveNetworkExists(true);
             mConnectivityDelegate.setNetworkType(i);
             mReceiver.onReceive(getInstrumentation().getTargetContext(), intent);
             assertTrue(NetworkChangeNotifier.isOnline());
         }
         mConnectivityDelegate.setActiveNetworkExists(false);
         mReceiver.onReceive(getInstrumentation().getTargetContext(), intent);
         assertFalse(NetworkChangeNotifier.isOnline());
     }
 }