Remove app context init from LibraryLoader.

components/invalidation/impl/android/javatests/src/org/chromium/components/invalidation/InvalidationClientServiceTest.java

 // Copyright 2013 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.components.invalidation;
 
 import android.accounts.Account;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
@@ skipping 40 matching lines @@
     /** Intents provided to {@link #startService}. */
     private List<Intent> mStartServiceIntents;
 
     public InvalidationClientServiceTest() {
         super(TestableInvalidationClientService.class);
     }
 
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        mStartServiceIntents = new ArrayList<Intent>();
+        mStartServiceIntents = new ArrayList<>();
         setContext(new AdvancedMockContext(getContext()) {
             @Override
             public ComponentName startService(Intent intent) {
                 mStartServiceIntents.add(intent);
                 return new ComponentName(this, InvalidationClientServiceTest.class);
             }
         });
         Context appContext = getContext().getApplicationContext();
         ContextUtils.initApplicationContextForTests(appContext);
         PathUtils.setPrivateDataDirectorySuffix(PRIVATE_DATA_DIRECTORY_SUFFIX, appContext);
-        LibraryLoader.get(LibraryProcessType.PROCESS_BROWSER).ensureInitialized(getContext());
+        LibraryLoader.get(LibraryProcessType.PROCESS_BROWSER).ensureInitialized();
         setupService();
     }
 
     @Override
     public void tearDown() throws Exception {
         if (InvalidationClientService.getIsClientStartedForTest()) {
             Intent stopIntent = createStopIntent();
             getService().onHandleIntent(stopIntent);
         }
         assertFalse(InvalidationClientService.getIsClientStartedForTest());
         super.tearDown();
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testComputeRegistrationOps() {
         /*
          * Test plan: compute the set of registration operations resulting from various combinations
          * of existing and desired registrations. Verifying that they are correct.
          */
-        Set<ObjectId> regAccumulator = new HashSet<ObjectId>();
-        Set<ObjectId> unregAccumulator = new HashSet<ObjectId>();
+        Set<ObjectId> regAccumulator = new HashSet<>();
+        Set<ObjectId> unregAccumulator = new HashSet<>();
 
         // Empty existing and desired registrations should yield empty operation sets.
         InvalidationClientService.computeRegistrationOps(
                 toObjectIdSet(ModelType.BOOKMARKS, ModelType.SESSIONS),
                 toObjectIdSet(ModelType.BOOKMARKS, ModelType.SESSIONS),
                 regAccumulator, unregAccumulator);
         assertEquals(0, regAccumulator.size());
         assertEquals(0, unregAccumulator.size());
 
         // Equal existing and desired registrations should yield empty operation sets.
         InvalidationClientService.computeRegistrationOps(new HashSet<ObjectId>(),
                 new HashSet<ObjectId>(), regAccumulator, unregAccumulator);
         assertEquals(0, regAccumulator.size());
         assertEquals(0, unregAccumulator.size());
 
         // Empty existing and non-empty desired registrations should yield desired registrations
         // as the registration operations to do and no unregistrations.
         Set<ObjectId> desiredTypes = toObjectIdSet(ModelType.BOOKMARKS, ModelType.SESSIONS);
         InvalidationClientService.computeRegistrationOps(
                 new HashSet<ObjectId>(),
                 desiredTypes,
                 regAccumulator, unregAccumulator);
         assertEquals(
                 toObjectIdSet(ModelType.BOOKMARKS, ModelType.SESSIONS),
-                new HashSet<ObjectId>(regAccumulator));
+                new HashSet<>(regAccumulator));
         assertEquals(0, unregAccumulator.size());
         regAccumulator.clear();
 
         // Unequal existing and desired registrations should yield both registrations and
         // unregistrations. We should unregister TYPED_URLS and register BOOKMARKS, keeping
         // SESSIONS.
         InvalidationClientService.computeRegistrationOps(
                 toObjectIdSet(ModelType.SESSIONS, ModelType.TYPED_URLS),
                 toObjectIdSet(ModelType.BOOKMARKS, ModelType.SESSIONS),
                 regAccumulator, unregAccumulator);
@@ skipping 22 matching lines @@
         // Issue ready.
         getService().ready(CLIENT_ID);
         assertTrue(Arrays.equals(CLIENT_ID, InvalidationClientService.getClientIdForTest()));
         byte[] otherCid = "otherCid".getBytes();
         getService().ready(otherCid);
         assertTrue(Arrays.equals(otherCid, InvalidationClientService.getClientIdForTest()));
 
         // Verify registrations issued.
         assertEquals(CollectionUtil.newHashSet(
                 toObjectId(ModelType.BOOKMARKS), toObjectId(ModelType.SESSIONS), objectId),
-                new HashSet<ObjectId>(getService().mRegistrations.get(0)));
+                new HashSet<>(getService().mRegistrations.get(0)));
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testReissueRegistrations() {
         /*
          * Test plan: call the reissueRegistrations method of the listener with both empty and
          * non-empty sets of desired registrations stored in preferences. Verify that no register
          * intent is set in the first case and that the appropriate register intent is sent in
          * the second.
          */
 
         // No persisted registrations.
         getService().reissueRegistrations(CLIENT_ID);
         assertTrue(getService().mRegistrations.isEmpty());
 
         // Persist some registrations.
         InvalidationPreferences invPrefs = new InvalidationPreferences();
         EditContext editContext = invPrefs.edit();
         invPrefs.setSyncTypes(editContext, CollectionUtil.newArrayList("BOOKMARK", "SESSION"));
         ObjectId objectId = ObjectId.newInstance(1, "obj".getBytes());
         invPrefs.setObjectIds(editContext, CollectionUtil.newArrayList(objectId));
         assertTrue(invPrefs.commit(editContext));
 
         // Reissue registrations and verify that the appropriate registrations are issued.
         getService().reissueRegistrations(CLIENT_ID);
         assertEquals(1, getService().mRegistrations.size());
         assertEquals(CollectionUtil.newHashSet(
                 toObjectId(ModelType.BOOKMARKS), toObjectId(ModelType.SESSIONS), objectId),
-                new HashSet<ObjectId>(getService().mRegistrations.get(0)));
+                new HashSet<>(getService().mRegistrations.get(0)));
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testInformRegistrationStatus() {
         /*
          * Test plan: call inform registration status under a variety of circumstances and verify
          * that the appropriate (un)register calls are issued.
          *
          * 1. Registration of desired object. No calls issued.
@@ skipping 369 matching lines @@
      * @param expectedObjectIds The additional object ids expected to be registered.
      * @param isReady Whether the client is ready to register/unregister.
      */
     private boolean expectedObjectIdsRegistered(Set<Integer> expectedTypes,
             Set<ObjectId> expectedObjectIds, boolean isReady) {
         // Get synced types saved to preferences.
         Set<String> expectedSyncTypes = modelTypesToNotificationTypes(expectedTypes);
         InvalidationPreferences invPrefs = new InvalidationPreferences();
         Set<String> actualSyncTypes = invPrefs.getSavedSyncedTypes();
         if (actualSyncTypes == null) {
-            actualSyncTypes = new HashSet<String>();
+            actualSyncTypes = new HashSet<>();
         }
 
         // Get object ids saved to preferences.
         Set<ObjectId> actualObjectIds = invPrefs.getSavedObjectIds();
         if (actualObjectIds == null) {
-            actualObjectIds = new HashSet<ObjectId>();
+            actualObjectIds = new HashSet<>();
         }
 
         // Get expected registered object ids.
-        Set<ObjectId> expectedRegisteredIds = new HashSet<ObjectId>();
+        Set<ObjectId> expectedRegisteredIds = new HashSet<>();
         if (isReady) {
             expectedRegisteredIds.addAll(modelTypesToObjectIds(expectedTypes));
             expectedRegisteredIds.addAll(expectedObjectIds);
         }
 
         return actualSyncTypes.equals(expectedSyncTypes)
                 && actualObjectIds.equals(expectedObjectIds)
                 && getService().mCurrentRegistrations.equals(expectedRegisteredIds);
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testRegistrationIntentWithTypesAndObjectIds() {
         /*
          * Test plan: send a mix of registration-change intents: some for Sync types and some for
          * object ids. Verify that registering for Sync types does not interfere with object id
          * registration and vice-versa.
          */
         getService().setShouldRunStates(true, true);
         getService().onCreate();
 
         Account account = AccountManagerHelper.createAccountFromName("test@example.com");
-        Set<ObjectId> objectIds = new HashSet<ObjectId>();
-        Set<Integer> types = new HashSet<Integer>();
+        Set<ObjectId> objectIds = new HashSet<>();
+        Set<Integer> types = new HashSet<>();
 
         // Register for some object ids.
         objectIds.add(ObjectId.newInstance(1, "obj1".getBytes()));
         objectIds.add(ObjectId.newInstance(2, "obj2".getBytes()));
         Intent registrationIntent =
                 createRegisterIntent(account, new int[] {1, 2}, new String[] {"obj1", "obj2"});
         getService().onHandleIntent(registrationIntent);
         assertTrue(expectedObjectIdsRegistered(types, objectIds, false /* isReady */));
 
         // Register for some types.
@@ skipping 69 matching lines @@
         assertTrue(isAndroidListenerStartIntent(mStartServiceIntents.get(0)));
 
         // Set client to be ready. This triggers registrations.
         getService().ready(CLIENT_ID);
         assertTrue(Arrays.equals(CLIENT_ID, InvalidationClientService.getClientIdForTest()));
 
         // Ensure registrations are correct.
         Set<ObjectId> expectedRegistrations =
                 modelTypesToObjectIds(CollectionUtil.newHashSet(ModelType.SESSIONS));
         assertEquals(expectedRegistrations,
-                     new HashSet<ObjectId>(getService().mRegistrations.get(0)));
+                     new HashSet<>(getService().mRegistrations.get(0)));
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testRegistrationIntentNoProxyTabsAlreadyWithClientId() {
         getService().setShouldRunStates(true, true);
         getService().onCreate();
 
         // Send register Intent with no desired types.
         Account account = AccountManagerHelper.createAccountFromName("test@example.com");
@@ skipping 14 matching lines @@
 
         // Send register Intent for SESSIONS and PROXY_TABS in an already ready client.
         registrationIntent = createRegisterIntent(account,
                 CollectionUtil.newHashSet(ModelType.PROXY_TABS, ModelType.SESSIONS));
         getService().onHandleIntent(registrationIntent);
 
         // Ensure that PROXY_TABS registration request is ignored.
         assertEquals(1, getService().mRegistrations.size());
         Set<ObjectId> expectedTypes =
                 modelTypesToObjectIds(CollectionUtil.newHashSet(ModelType.SESSIONS));
-        assertEquals(expectedTypes, new HashSet<ObjectId>(getService().mRegistrations.get(0)));
+        assertEquals(expectedTypes, new HashSet<>(getService().mRegistrations.get(0)));
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testRegistrationIntentWhenClientShouldNotBeRunning() {
         /*
          * Test plan: send a registration change event when the client should not be running.
          * Verify that the service updates the on-disk state but does not start the client.
          */
         getService().onCreate();
@@ skipping 47 matching lines @@
         Intent expectedRegisterIntent = AndroidListener.createRegisterIntent(
                 getContext(),
                 CLIENT_ID,
                 desiredObjectIds);
         Intent actualRegisterIntent = mStartServiceIntents.get(1);
         assertTrue(expectedRegisterIntent.filterEquals(actualRegisterIntent));
         assertEquals(expectedRegisterIntent.getExtras().keySet(),
                 actualRegisterIntent.getExtras().keySet());
         assertEquals(
                 desiredObjectIds,
-                new HashSet<ObjectId>(getService().mRegistrations.get(0)));
+                new HashSet<>(getService().mRegistrations.get(0)));
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testNullIntent() {
         getService().setShouldRunStates(true, true);
         getService().onCreate();
         // onHandleIntent must gracefully handle receiving a null intent.
         getService().onHandleIntent(null);
         // No crash == success.
@@ skipping 10 matching lines @@
          */
         // TODO(dsmyers): implement.
         // Bug: https://code.google.com/p/chromium/issues/detail?id=172398
     }
 
     private ObjectId toObjectId(int modelType) {
         return ModelTypeHelper.toObjectId(modelType);
     }
 
     private Set<ObjectId> toObjectIdSet(int... modelTypes) {
-        Set<ObjectId> objectIds = new HashSet<ObjectId>(modelTypes.length);
+        Set<ObjectId> objectIds = new HashSet<>(modelTypes.length);
         for (int i = 0; i < modelTypes.length; i++) {
             objectIds.add(toObjectId(modelTypes[i]));
         }
         return objectIds;
     }
 
     private Set<ObjectId> modelTypesToObjectIds(Set<Integer> modelTypes) {
-        Set<ObjectId> objectIds = new HashSet<ObjectId>();
+        Set<ObjectId> objectIds = new HashSet<>();
         for (Integer modelType : modelTypes) {
             objectIds.add(toObjectId(modelType));
         }
         return objectIds;
     }
 
     private Set<String> modelTypesToNotificationTypes(Set<Integer> modelTypes) {
-        Set<String> strings = new HashSet<String>();
+        Set<String> strings = new HashSet<>();
         for (Integer modelType : modelTypes) {
             strings.add(ModelTypeHelper.toNotificationType(modelType));
         }
         return strings;
     }
 
     /** Creates an intent to start the InvalidationClientService. */
     private Intent createStartIntent() {
         Intent intent = new Intent();
         return intent;
@@ skipping 26 matching lines @@
                 InvalidationClientService.CLIENT_TYPE, "unused".getBytes());
         return intent.getExtras().keySet().equals(startIntent.getExtras().keySet());
     }
 
     /** Returns whether {@code intent} is an {@link AndroidListener} stop intent. */
     private boolean isAndroidListenerStopIntent(Intent intent) {
         Intent stopIntent = AndroidListener.createStopIntent(getContext());
         return intent.getExtras().keySet().equals(stopIntent.getExtras().keySet());
     }
 }