chrome[android]: Restrict the use of startService for invalidations.

chrome/android/java/src/org/chromium/chrome/browser/invalidation/InvalidationController.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.chrome.browser.invalidation;
 
 import android.content.Context;
 import android.content.Intent;
 import android.os.AsyncTask;
 import android.os.Handler;
 import android.os.SystemClock;
 
 import com.google.ipc.invalidation.ticl.android2.channel.AndroidGcmController;
 
 import org.chromium.base.ApplicationState;
 import org.chromium.base.ApplicationStatus;
+import org.chromium.base.BuildInfo;
 import org.chromium.base.FieldTrialList;
+import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.chrome.browser.ChromeFeatureList;
 import org.chromium.chrome.browser.sync.ProfileSyncService;
 import org.chromium.components.invalidation.InvalidationClientService;
 import org.chromium.components.signin.ChromeSigninController;
 import org.chromium.components.sync.AndroidSyncSettings;
 import org.chromium.components.sync.ModelType;
 import org.chromium.components.sync.notifier.InvalidationIntentProtocol;
 
 import java.util.HashSet;
 
 /**
  * Controller used to send start, stop, and registration-change commands to the invalidation
  * client library used by Sync.
  */
 public class InvalidationController implements ApplicationStatus.ApplicationStateListener {
+    private static final String TAG = "cr_invalidation";
+
     /**
      * Timer which can be paused. When the timer is paused, the execution of its scheduled task is
      * delayed till the timer is resumed.
      */
     private static class Timer {
         private Handler mHandler;
 
         /**
          * Runnable which is added to the handler's message queue.
          */
@@ skipping 143 matching lines @@
             typesToRegister.remove(ModelType.SESSIONS);
             typesToRegister.remove(ModelType.FAVICON_TRACKING);
             typesToRegister.remove(ModelType.FAVICON_IMAGES);
         }
 
         Intent registerIntent = InvalidationIntentProtocol.createRegisterIntent(
                 ChromeSigninController.get(mContext).getSignedInUser(),
                 typesToRegister);
         registerIntent.setClass(
                 mContext, InvalidationClientService.getRegisteredClass());
+
+        if (shouldRestrictBackgroundServices()) {
+            Log.e(TAG, "Failed to register types");
+            return;
+        }
         mContext.startService(registerIntent);
     }
 
     /**
      * Registers for Google Cloud Messaging (GCM) for Invalidations.
      */
     private void ensureGcmIsInitialized() {
         if (mGcmInitialized) return;
         mGcmInitialized = true;
         new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... arg0) {
                 AndroidGcmController.get(mContext).initializeGcm(mUseGcmUpstream);
                 return null;
             }
         }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
     }
 
     @VisibleForTesting
     public boolean isGcmInitialized() {
         return mGcmInitialized;
     }
 
     /**
      * Starts the invalidation client without updating the registered invalidation types.
      */
     private void start() {
+        if (shouldRestrictBackgroundServices()) {
+            Log.e(TAG, "Failed to start invalidation client");
+            return;
+        }
+
         mStarted = true;
         mEnableSessionInvalidationsTimer.resume();
         Intent intent = new Intent(
                 mContext, InvalidationClientService.getRegisteredClass());
         mContext.startService(intent);
     }
 
     /**
      * Stops the invalidation client.
      */
     public void stop() {
+        if (shouldRestrictBackgroundServices()) {
+            Log.e(TAG, "Failed to stop invalidation client");
+            return;
+        }
+
         mStarted = false;
         mEnableSessionInvalidationsTimer.pause();
         Intent intent = new Intent(
                 mContext, InvalidationClientService.getRegisteredClass());
         intent.putExtra(InvalidationIntentProtocol.EXTRA_STOP, true);
         mContext.startService(intent);
     }
 
     /**
      * Returns whether the invalidation client has been started.
@@ skipping 87 matching lines @@
         if (appContext == null) throw new NullPointerException("Unable to get application context");
         mContext = appContext;
         mUseGcmUpstream = canUseGcmUpstream;
         mCanDisableSessionInvalidations = canDisableSessionInvalidations;
         mSessionInvalidationsEnabled = !mCanDisableSessionInvalidations;
         mEnableSessionInvalidationsTimer = new Timer();
 
         ApplicationStatus.registerApplicationStateListener(this);
     }
 
+    private boolean shouldRestrictBackgroundServices() {
+        // Restricts the use of background services when not in foreground. See crbug.com/680812.
+        return BuildInfo.isGreaterThanN() && !ApplicationStatus.hasVisibleActivities();
+    }
+
     @Override
     public void onApplicationStateChange(int newState) {
         // The isSyncEnabled() check is used to check whether the InvalidationController would be
         // started if it did not stop itself when the application is paused.
         if (AndroidSyncSettings.isSyncEnabled(mContext)) {
             if (newState == ApplicationState.HAS_RUNNING_ACTIVITIES) {
                 start();
             } else if (newState == ApplicationState.HAS_PAUSED_ACTIVITIES) {
                 stop();
             }
         }
     }
 }