[Android] Remove all usage of com.google.common.collect

sync/android/java/src/org/chromium/sync/notifier/InvalidationService.java

 // Copyright (c) 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.sync.notifier;
 
 import android.accounts.Account;
 import android.app.PendingIntent;
 import android.content.ContentResolver;
 import android.content.Intent;
 import android.os.Bundle;
 import android.util.Log;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
 import com.google.ipc.invalidation.external.client.InvalidationListener.RegistrationState;
 import com.google.ipc.invalidation.external.client.contrib.AndroidListener;
 import com.google.ipc.invalidation.external.client.types.ErrorInfo;
 import com.google.ipc.invalidation.external.client.types.Invalidation;
 import com.google.ipc.invalidation.external.client.types.ObjectId;
 import com.google.protos.ipc.invalidation.Types.ClientType;
 
 import org.chromium.base.ActivityStatus;
 import org.chromium.sync.internal_api.pub.base.ModelType;
 import org.chromium.sync.notifier.InvalidationController.IntentProtocol;
 import org.chromium.sync.notifier.InvalidationPreferences.EditContext;
 import org.chromium.sync.signin.AccountManagerHelper;
 import org.chromium.sync.signin.ChromeSigninController;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Random;
 import java.util.Set;
 
 import javax.annotation.Nullable;
 
 /**
  * Service that controls notifications for sync.
  * <p>
  * This service serves two roles. On the one hand, it is a client for the notification system
@@ skipping 46 matching lines @@
         ensureClientStartState();
 
         // Handle the intent.
         if (IntentProtocol.isStop(intent) && sIsClientStarted) {
             // If the intent requests that the client be stopped, stop it.
             stopClient();
         } else if (IntentProtocol.isRegisteredTypesChange(intent)) {
             // If the intent requests a change in registrations, change them.
             List<String> regTypes =
                     intent.getStringArrayListExtra(IntentProtocol.EXTRA_REGISTERED_TYPES);
-            setRegisteredTypes(Sets.newHashSet(regTypes));
+            setRegisteredTypes(new HashSet<String>(regTypes));
         } else {
             // Otherwise, we don't recognize the intent. Pass it to the notification client service.
             super.onHandleIntent(intent);
         }
     }
 
     @Override
     public void invalidate(Invalidation invalidation, byte[] ackHandle) {
         byte[] payload = invalidation.getPayload();
         String payloadStr = (payload == null) ? null : new String(payload);
@@ skipping 14 matching lines @@
     }
 
     @Override
     public void informRegistrationFailure(
             byte[] clientId, ObjectId objectId, boolean isTransient, String errorMessage) {
         Log.w(TAG, "Registration failure on " + objectId + " ; transient = " + isTransient
                 + ": " + errorMessage);
         if (isTransient) {
           // Retry immediately on transient failures. The base AndroidListener will handle
           // exponential backoff if there are repeated failures.
-          List<ObjectId> objectIdAsList = Lists.newArrayList(objectId);
+          List<ObjectId> objectIdAsList = new ArrayList<ObjectId>();

[nyquist, 2013/08/20 19:01:57]

CollectionUtil.newArrayList here and below.

[Yaron, 2013/08/20 23:41:31]

Done.

+          objectIdAsList.add(objectId);
           if (readRegistrationsFromPrefs().contains(objectId)) {
               register(clientId, objectIdAsList);
           } else {
               unregister(clientId, objectIdAsList);
           }
         }
     }
 
     @Override
     public void informRegistrationStatus(
             byte[] clientId, ObjectId objectId, RegistrationState regState) {
         Log.d(TAG, "Registration status for " + objectId + ": " + regState);
-        List<ObjectId> objectIdAsList = Lists.newArrayList(objectId);
+        List<ObjectId> objectIdAsList = new ArrayList<ObjectId>();
+        objectIdAsList.add(objectId);
         boolean registrationisDesired = readRegistrationsFromPrefs().contains(objectId);
         if (regState == RegistrationState.REGISTERED) {
           if (!registrationisDesired) {
             Log.i(TAG, "Unregistering for object we're no longer interested in");
             unregister(clientId, objectIdAsList);
           }
         } else {
           if (registrationisDesired) {
             Log.i(TAG, "Registering for an object");
             register(clientId, objectIdAsList);
@@ skipping 164 matching lines @@
         // return. Later, when the client is ready, we will supply the new registrations.
         if (sClientId == null) {
             return;
         }
 
         // We do have a ready client. Unregister any existing registrations not present in the
         // new set and register any elements in the new set not already present. This call does
         // expansion of the ALL_TYPES_TYPE wildcard.
         // NOTE: syncTypes MUST NOT be used below this line, since it contains an unexpanded
         // wildcard.
-        List<ObjectId> unregistrations = Lists.newArrayList();
-        List<ObjectId> registrations = Lists.newArrayList();
+        Set<ObjectId> unregistrations = new HashSet<ObjectId>();
+        Set<ObjectId> registrations = new HashSet<ObjectId>();
         computeRegistrationOps(existingRegistrations,
                 ModelType.syncTypesToObjectIds(syncTypes),
                 registrations, unregistrations);
         unregister(sClientId, unregistrations);
         register(sClientId, registrations);
     }
 
     /**
      * Computes the set of (un)registrations to perform so that the registrations active in the
      * Ticl will be {@code desiredRegs}, given that {@existingRegs} already exist.
      *
      * @param regAccumulator registrations to perform
      * @param unregAccumulator unregistrations to perform.
      */
     @VisibleForTesting
     static void computeRegistrationOps(Set<ObjectId> existingRegs, Set<ObjectId> desiredRegs,
-            Collection<ObjectId> regAccumulator, Collection<ObjectId> unregAccumulator) {
+            Set<ObjectId> regAccumulator, Set<ObjectId> unregAccumulator) {
+
         // Registrations to do are elements in the new set but not the old set.
-        regAccumulator.addAll(Sets.difference(desiredRegs, existingRegs));
+        regAccumulator.addAll(desiredRegs);
+        regAccumulator.removeAll(existingRegs);
 
         // Unregistrations to do are elements in the old set but not the new set.
-        unregAccumulator.addAll(Sets.difference(existingRegs, desiredRegs));
+        unregAccumulator.addAll(existingRegs);
+        unregAccumulator.removeAll(desiredRegs);
     }
 
     /**
      * Requests that the sync system perform a sync.
      *
      * @param objectId the object that changed, if known.
      * @param version the version of the object that changed, if known.
      * @param payload the payload of the change, if known.
      */
     private void requestSync(@Nullable ObjectId objectId, @Nullable Long version,
@@ skipping 79 matching lines @@
     }
 
     private static void setClientId(byte[] clientId) {
         sClientId = clientId;
     }
 
     private static void setIsClientStarted(boolean isStarted) {
         sIsClientStarted = isStarted;
     }
 }