Moving BindingManager and ChildProcessConnection to base/.

base/android/java/src/org/chromium/base/process_launcher/BindingManagerImpl.java

 // Copyright 2014 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.content.browser;
+package org.chromium.base.process_launcher;
 
 import android.annotation.TargetApi;
 import android.content.ComponentCallbacks2;
 import android.content.Context;
 import android.content.res.Configuration;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
 import android.util.LruCache;
 import android.util.SparseArray;
 
 import org.chromium.base.Log;
 import org.chromium.base.SysUtils;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.metrics.RecordHistogram;
 
 import java.util.Map;
 
 /**
  * Manages oom bindings used to bound child services.
  * This object must only be accessed from the launcher thread.
  */
-class BindingManagerImpl implements BindingManager {
-    private static final String TAG = "cr.BindingManager";
+public class BindingManagerImpl implements BindingManager {
+    private static final String TAG = "cr_BindingManager";
 
     // Low reduce ratio of moderate binding.
     private static final float MODERATE_BINDING_LOW_REDUCE_RATIO = 0.25f;
     // High reduce ratio of moderate binding.
     private static final float MODERATE_BINDING_HIGH_REDUCE_RATIO = 0.5f;
 
     // Delay of 1 second used when removing temporary strong binding of a process (only on
     // non-low-memory devices).
     private static final long DETACH_AS_ACTIVE_HIGH_END_DELAY_MILLIS = 1 * 1000;
 
     // Delays used when clearing moderate binding pool when onSentToBackground happens.
     private static final long MODERATE_BINDING_POOL_CLEARER_DELAY_MILLIS = 10 * 1000;
 
+    // The handler for the thread this BindingManager should be accessed on.
+    private final Handler mHandler;
+
     // These fields allow to override the parameters for testing - see
     // createBindingManagerForTesting().
     private final boolean mIsLowMemoryDevice;
 
-    private static class ModerateBindingPool
+    private class ModerateBindingPool
             extends LruCache<Integer, ManagedConnection> implements ComponentCallbacks2 {
         private Runnable mDelayedClearer;
 
         public ModerateBindingPool(int maxSize) {
             super(maxSize);
         }
 
         @Override
         public void onTrimMemory(final int level) {
             ThreadUtils.assertOnUiThread();
-            LauncherThread.post(new Runnable() {
+            mHandler.post(new Runnable() {
                 @Override
                 public void run() {
                     Log.i(TAG, "onTrimMemory: level=%d, size=%d", level, size());
                     if (size() <= 0) {
                         return;
                     }
                     if (level <= TRIM_MEMORY_RUNNING_MODERATE) {
                         reduce(MODERATE_BINDING_LOW_REDUCE_RATIO);
                     } else if (level <= TRIM_MEMORY_RUNNING_LOW) {
                         reduce(MODERATE_BINDING_HIGH_REDUCE_RATIO);
                     } else if (level == TRIM_MEMORY_UI_HIDDEN) {
                         // This will be handled by |mDelayedClearer|.
                         return;
                     } else {
                         evictAll();
                     }
                 }
             });
         }
 
         @Override
         public void onLowMemory() {
             ThreadUtils.assertOnUiThread();
-            LauncherThread.post(new Runnable() {
+            mHandler.post(new Runnable() {
                 @Override
                 public void run() {
                     Log.i(TAG, "onLowMemory: evict %d bindings", size());
                     evictAll();
                 }
             });
         }
 
         @Override
         public void onConfigurationChanged(Configuration configuration) {}
@@ skipping 54 matching lines @@
                     if (mDelayedClearer == null) return;
                     mDelayedClearer = null;
                     Log.i(TAG, "Release moderate connections: %d", size());
                     if (!onTesting) {
                         RecordHistogram.recordCountHistogram(
                                 "Android.ModerateBindingCount", size());
                     }
                     evictAll();
                 }
             };
-            LauncherThread.postDelayed(mDelayedClearer, MODERATE_BINDING_POOL_CLEARER_DELAY_MILLIS);
+            mHandler.postDelayed(mDelayedClearer, MODERATE_BINDING_POOL_CLEARER_DELAY_MILLIS);
         }
 
         void onBroughtToForeground() {
             if (mDelayedClearer != null) {
-                LauncherThread.removeCallbacks(mDelayedClearer);
+                mHandler.removeCallbacks(mDelayedClearer);
                 mDelayedClearer = null;
             }
         }
     }
 
     private ModerateBindingPool mModerateBindingPool;
 
     /**
      * Wraps ManagedChildProcessConnection keeping track of additional information needed to manage
      * the bindings of the connection. The reference to ManagedChildProcessConnection is cleared
@@ skipping 51 matching lines @@
                         if (keepAsModerate) {
                             addConnectionToModerateBindingPool(connection);
                         }
                     }
                 }
             };
 
             if (mIsLowMemoryDevice) {
                 doUnbind.run();
             } else {
-                LauncherThread.postDelayed(doUnbind, DETACH_AS_ACTIVE_HIGH_END_DELAY_MILLIS);
+                mHandler.postDelayed(doUnbind, DETACH_AS_ACTIVE_HIGH_END_DELAY_MILLIS);
             }
         }
 
         /**
          * Adds connection to the moderate binding pool. No-op if the connection has a strong
          * binding.
          * @param connection The ChildProcessConnection to add to the moderate binding pool.
          */
         private void addConnectionToModerateBindingPool(ManagedChildProcessConnection connection) {
             if (mModerateBindingPool != null && !connection.isStrongBindingBound()) {
@@ skipping 87 matching lines @@
     // The connection bound with additional binding in onSentToBackground().
     private ManagedConnection mBoundForBackgroundPeriod;
 
     // Whether this instance is used on testing.
     private final boolean mOnTesting;
 
     /**
      * The constructor is private to hide parameters exposed for testing from the regular consumer.
      * Use factory methods to create an instance.
      */
-    private BindingManagerImpl(boolean isLowMemoryDevice, boolean onTesting) {
-        assert LauncherThread.runningOnLauncherThread();
+    private BindingManagerImpl(Handler handler, boolean isLowMemoryDevice, boolean onTesting) {
+        mHandler = handler;
+        checkOnValidThread();
         mIsLowMemoryDevice = isLowMemoryDevice;
         mOnTesting = onTesting;
     }
 
-    public static BindingManagerImpl createBindingManager() {
-        assert LauncherThread.runningOnLauncherThread();
-        return new BindingManagerImpl(SysUtils.isLowEndDevice(), false);
+    public static BindingManagerImpl createBindingManager(Handler handler) {
+        return new BindingManagerImpl(handler, SysUtils.isLowEndDevice(), false);
     }
 
     /**
      * Creates a testing instance of BindingManager. Testing instance will have the unbinding delays
      * set to 0, so that the tests don't need to deal with actual waiting.
      * @param isLowEndDevice true iff the created instance should apply low-end binding policies
      */
-    public static BindingManagerImpl createBindingManagerForTesting(boolean isLowEndDevice) {
-        assert LauncherThread.runningOnLauncherThread();
-        return new BindingManagerImpl(isLowEndDevice, true);
+    public static BindingManagerImpl createBindingManagerForTesting(
+            Handler handler, boolean isLowEndDevice) {
+        return new BindingManagerImpl(handler, isLowEndDevice, true);
     }
 
     @Override
     public void addNewConnection(int pid, ManagedChildProcessConnection connection) {
-        assert LauncherThread.runningOnLauncherThread();
+        checkOnValidThread();
         // This will reset the previous entry for the pid in the unlikely event of the OS
         // reusing renderer pids.
         mManagedConnections.put(pid, new ManagedConnection(connection));
     }
 
     @Override
     public void setInForeground(int pid, boolean inForeground) {
-        assert LauncherThread.runningOnLauncherThread();
+        checkOnValidThread();
         ManagedConnection managedConnection = mManagedConnections.get(pid);
         if (managedConnection == null) {
             Log.w(TAG, "Cannot setInForeground() - never saw a connection for the pid: %d", pid);
             return;
         }
 
         if (inForeground && mIsLowMemoryDevice && mLastInForeground != null
                 && mLastInForeground != managedConnection) {
             mLastInForeground.dropBindings();
         }
 
         managedConnection.setInForeground(inForeground);
         if (inForeground) mLastInForeground = managedConnection;
     }
 
     @Override
     public void onDeterminedVisibility(int pid) {
-        assert LauncherThread.runningOnLauncherThread();
+        checkOnValidThread();
         ManagedConnection managedConnection = mManagedConnections.get(pid);
         if (managedConnection == null) {
-            Log.w(TAG, "Cannot call determinedVisibility() - never saw a connection for the pid: "
-                    + "%d", pid);
+            Log.w(TAG,
+                    "Cannot call determinedVisibility() - never saw a connection for the pid: "
+                            + "%d",
+                    pid);
             return;
         }
 
         managedConnection.onDeterminedVisibility();
     }
 
     @Override
     public void onSentToBackground() {
-        assert LauncherThread.runningOnLauncherThread();
+        checkOnValidThread();
         assert mBoundForBackgroundPeriod == null;
         // mLastInForeground can be null at this point as the embedding application could be
         // used in foreground without spawning any renderers.
         if (mLastInForeground != null) {
             mLastInForeground.setBoundForBackgroundPeriod(true);
             mBoundForBackgroundPeriod = mLastInForeground;
         }
         if (mModerateBindingPool != null) mModerateBindingPool.onSentToBackground(mOnTesting);
     }
 
     @Override
     public void onBroughtToForeground() {
-        assert LauncherThread.runningOnLauncherThread();
+        checkOnValidThread();
         if (mBoundForBackgroundPeriod != null) {
             mBoundForBackgroundPeriod.setBoundForBackgroundPeriod(false);
             mBoundForBackgroundPeriod = null;
         }
         if (mModerateBindingPool != null) mModerateBindingPool.onBroughtToForeground();
     }
 
     @Override
     public void removeConnection(int pid) {
-        assert LauncherThread.runningOnLauncherThread();
+        checkOnValidThread();
         ManagedConnection managedConnection = mManagedConnections.get(pid);
         if (managedConnection != null) {
             mManagedConnections.remove(pid);
             managedConnection.clearConnection();
         }
     }
 
     /** @return true iff the connection reference is no longer held */
     @VisibleForTesting
     public boolean isConnectionCleared(int pid) {
-        assert LauncherThread.runningOnLauncherThread();
+        checkOnValidThread();
         return mManagedConnections.get(pid) == null;
     }
 
     @Override
     public void startModerateBindingManagement(Context context, int maxSize) {
-        assert LauncherThread.runningOnLauncherThread();
+        checkOnValidThread();
         if (mIsLowMemoryDevice) return;
 
         if (mModerateBindingPool == null) {
             Log.i(TAG, "Moderate binding enabled: maxSize=%d", maxSize);
             mModerateBindingPool = new ModerateBindingPool(maxSize);
             if (context != null) {
                 // Note that it is safe to call Context.registerComponentCallbacks from a background
                 // thread.
                 context.registerComponentCallbacks(mModerateBindingPool);
             }
         }
     }
 
     @Override
     public void releaseAllModerateBindings() {
-        assert LauncherThread.runningOnLauncherThread();
+        checkOnValidThread();
         if (mModerateBindingPool != null) {
             Log.i(TAG, "Release all moderate bindings: %d", mModerateBindingPool.size());
             mModerateBindingPool.evictAll();
         }
     }
+
+    /** Checks whether the caller is running on the thread specified at creation time. */
+    private final void checkOnValidThread() {
+        assert mHandler.getLooper() == Looper.myLooper();
+    }
 }