Introduce moderate binding

content/public/android/java/src/org/chromium/content/browser/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;
 
-import android.util.Log;
+import android.annotation.TargetApi;
+import android.content.ComponentCallbacks2;
+import android.content.Context;
+import android.content.res.Configuration;
+import android.os.Build;
+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.
  */
 class BindingManagerImpl implements BindingManager {
-    private static final String TAG = "BindingManager";
+    private static final String TAG = "cr.BindingManager";
 
     // 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;
 
     // These fields allow to override the parameters for testing - see
     // createBindingManagerForTesting().
     private final long mRemoveStrongBindingDelay;
     private final boolean mIsLowMemoryDevice;
 
+    private static class ModerateBindingPool
+            extends LruCache<Integer, ManagedConnection> implements ComponentCallbacks2 {
+        private final float mLowReduceRatio;
+        private final float mHighReduceRatio;
+
+        public ModerateBindingPool(int maxSize, float lowReduceRatio, float highReduceRatio) {
+            super(maxSize);
+
+            mLowReduceRatio = lowReduceRatio;
+            mHighReduceRatio = highReduceRatio;
+        }
+
+        @Override
+        public void onTrimMemory(int level) {
+            Log.i(TAG, "onTrimMemory: level=" + level + ", size=" + size());
+            if (size() > 0) {
+                if (level <= TRIM_MEMORY_RUNNING_MODERATE) {
+                    reduce(mLowReduceRatio);
+                } else if (level <= TRIM_MEMORY_RUNNING_LOW) {
+                    reduce(mHighReduceRatio);
+                } else {
+                    evictAll();
+                }
+            }
+        }
+
+        @Override
+        public void onLowMemory() {
+            Log.i(TAG, "onLowMemory: evict " + size() + " bindings");
+            evictAll();
+        }
+
+        @Override
+        public void onConfigurationChanged(Configuration configuration) {}
+
+        @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
+        private void reduce(float reduceRatio) {
+            int oldSize = size();
+            int newSize = (int) (oldSize * (1f - reduceRatio));
+            Log.i(TAG, "Reduce connections from " + oldSize + " to " + newSize);
+            if (newSize == 0) {
+                evictAll();
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+                trimToSize(newSize);
+            } else {

[Jaekyun Seok (inactive), 2015/06/22 03:17:52]

I realized that LruCache.trimToSize is available only since Android API 17. So I
added my own logic to trim LruCache for lower APIs.

+                int count = 0;
+                for (Map.Entry<Integer, ManagedConnection> entry : snapshot().entrySet()) {

[Alexei Svitkine (slow), 2015/06/22 14:58:52]

Nit: Add a comment explaining why this makes sense (i.e. that snapshot() returns
things ordered from least recently to most recently accessed).

[Jaekyun Seok (inactive), 2015/06/22 21:24:48]

Done.

+                    remove(entry.getKey());
+                    ++count;
+                    if (count == oldSize - newSize) break;
+                }
+            }
+        }
+
+        void addConnection(ManagedConnection managedConnection) {
+            ChildProcessConnection connection = managedConnection.mConnection;
+            if (connection != null && connection.isInSandbox()) {
+                managedConnection.addModerateBinding();
+                if (connection.isModerateBindingBound()) {
+                    put(connection.getServiceNumber(), managedConnection);
+                } else {
+                    remove(connection.getServiceNumber());
+                }
+            }
+        }
+
+        void removeConnection(ManagedConnection managedConnection) {
+            ChildProcessConnection connection = managedConnection.mConnection;
+            if (connection != null && connection.isInSandbox()) {
+                remove(connection.getServiceNumber());
+            }
+        }
+
+        @Override
+        protected void entryRemoved(boolean evicted, Integer key, ManagedConnection oldValue,
+                ManagedConnection newValue) {
+            if (oldValue != newValue) {
+                oldValue.removeModerateBinding();
+            }
+        }
+    }
+
+    private ModerateBindingPool mModerateBindingPool;
+
     /**
      * Wraps ChildProcessConnection keeping track of additional information needed to manage the
      * bindings of the connection. The reference to ChildProcessConnection is cleared when the
      * connection goes away, but ManagedConnection itself is kept (until overwritten by a new entry
      * for the same pid).
      */
     private class ManagedConnection {
         // Set in constructor, cleared in clearConnection().
         private ChildProcessConnection mConnection;
 
@@ skipping 13 matching lines @@
             if (mConnection == null || !mConnection.isInitialBindingBound()) return;
             mConnection.removeInitialBinding();
         }
 
         /** Adds a strong service binding. */
         private void addStrongBinding() {
             ChildProcessConnection connection = mConnection;
             if (connection == null) return;
 
             connection.addStrongBinding();
+            if (mModerateBindingPool != null) {
+                mModerateBindingPool.removeConnection(this);
+            }
         }
 
         /** Removes a strong service binding. */
-        private void removeStrongBinding() {
+        private void removeStrongBinding(final boolean keepsAsModerate) {
             final ChildProcessConnection connection = mConnection;
             // We have to fail gracefully if the strong binding is not present, as on low-end the
             // binding could have been removed by dropOomBindings() when a new service was started.
             if (connection == null || !connection.isStrongBindingBound()) return;
 
             // This runnable performs the actual unbinding. It will be executed synchronously when
             // on low-end devices and posted with a delay otherwise.
             Runnable doUnbind = new Runnable() {
                 @Override
                 public void run() {
                     if (connection.isStrongBindingBound()) {
                         connection.removeStrongBinding();
+                        if (mModerateBindingPool != null && !connection.isStrongBindingBound()
+                                && keepsAsModerate) {
+                            mModerateBindingPool.addConnection(ManagedConnection.this);
+                        }
                     }
                 }
             };
 
             if (mIsLowMemoryDevice) {
                 doUnbind.run();
             } else {
                 ThreadUtils.postOnUiThreadDelayed(doUnbind, mRemoveStrongBindingDelay);
             }
         }
 
+        /** Removes the moderate service binding. */
+        private void removeModerateBinding() {
+            if (mConnection == null || !mConnection.isModerateBindingBound()) return;
+            mConnection.removeModerateBinding();
+        }
+
+        /** Adds the moderate service binding. */
+        private void addModerateBinding() {
+            ChildProcessConnection connection = mConnection;
+            if (connection == null) return;
+
+            connection.addModerateBinding();
+        }
+
         /**
          * Drops the service bindings. This is used on low-end to drop bindings of the current
          * service when a new one is used in foreground.
          */
         private void dropBindings() {
             assert mIsLowMemoryDevice;
             ChildProcessConnection connection = mConnection;
             if (connection == null) return;
 
             connection.dropOomBindings();
         }
 
         ManagedConnection(ChildProcessConnection connection) {
             mConnection = connection;
         }
 
         /**
          * Sets the visibility of the service, adding or removing the strong binding as needed.
          */
         void setInForeground(boolean nextInForeground) {
             if (!mInForeground && nextInForeground) {
                 addStrongBinding();
             } else if (mInForeground && !nextInForeground) {
-                removeStrongBinding();
+                removeStrongBinding(true);
             }
 
             mInForeground = nextInForeground;
         }
 
         /**
          * Removes the initial binding.
          */
         void determinedVisibility() {
             removeInitialBinding();
         }
 
         /**
          * Sets or removes additional binding when the service is main service during the embedder
          * background period.
          */
         void setBoundForBackgroundPeriod(boolean nextBound) {
             if (!mBoundForBackgroundPeriod && nextBound) {
                 addStrongBinding();
             } else if (mBoundForBackgroundPeriod && !nextBound) {
-                removeStrongBinding();
+                removeStrongBinding(false);
             }
 
             mBoundForBackgroundPeriod = nextBound;
         }
 
         boolean isOomProtected() {
             // When a process crashes, we can be queried about its oom status before or after the
             // connection is cleared. For the latter case, the oom status is stashed in
             // mWasOomProtected.
             return mConnection != null
                     ? mConnection.isOomProtectedOrWasWhenDied() : mWasOomProtected;
         }
 
         void clearConnection() {
             mWasOomProtected = mConnection.isOomProtectedOrWasWhenDied();
+            if (mModerateBindingPool != null) {
+                mModerateBindingPool.removeConnection(this);
+            }
             mConnection = null;
         }
 
         /** @return true iff the reference to the connection is no longer held */
         @VisibleForTesting
         boolean isConnectionCleared() {
             return mConnection == null;
         }
     }
 
     // This can be manipulated on different threads, synchronize access on mManagedConnections.
     private final SparseArray<ManagedConnection> mManagedConnections =
             new SparseArray<ManagedConnection>();
 
     // The connection that was most recently set as foreground (using setInForeground()). This is
     // used to add additional binding on it when the embedder goes to background. On low-end, this
     // is also used to drop process bidnings when a new one is created, making sure that only one
     // renderer process at a time is protected from oom killing.
     private ManagedConnection mLastInForeground;
 
     // Synchronizes operations that access mLastInForeground: setInForeground() and
     // addNewConnection().
     private final Object mLastInForegroundLock = new Object();
 
     // 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, long removeStrongBindingDelay) {
+    private BindingManagerImpl(
+            boolean isLowMemoryDevice, long removeStrongBindingDelay, boolean onTesting) {
         mIsLowMemoryDevice = isLowMemoryDevice;
         mRemoveStrongBindingDelay = removeStrongBindingDelay;
+        mOnTesting = onTesting;
     }
 
     public static BindingManagerImpl createBindingManager() {
-        return new BindingManagerImpl(SysUtils.isLowEndDevice(),
-                DETACH_AS_ACTIVE_HIGH_END_DELAY_MILLIS);
+        return new BindingManagerImpl(
+                SysUtils.isLowEndDevice(), DETACH_AS_ACTIVE_HIGH_END_DELAY_MILLIS, 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) {
-        return new BindingManagerImpl(isLowEndDevice, 0);
+        return new BindingManagerImpl(isLowEndDevice, 0, true);
     }
 
     @Override
     public void addNewConnection(int pid, ChildProcessConnection connection) {
         // This will reset the previous entry for the pid in the unlikely event of the OS
         // reusing renderer pids.
         synchronized (mManagedConnections) {
             mManagedConnections.put(pid, new ManagedConnection(connection));
         }
     }
@@ skipping 42 matching lines @@
     public void onSentToBackground() {
         assert mBoundForBackgroundPeriod == null;
         synchronized (mLastInForegroundLock) {
             // 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) {
+            Log.i(TAG, "Release moderate connections: " + mModerateBindingPool.size());
+            if (!mOnTesting) {
+                RecordHistogram.recordCountHistogram(
+                        "Android.ModerateBindingCount", mModerateBindingPool.size());
+            }
+            mModerateBindingPool.evictAll();
+        }
     }
 
     @Override
     public void onBroughtToForeground() {
         if (mBoundForBackgroundPeriod != null) {
             mBoundForBackgroundPeriod.setBoundForBackgroundPeriod(false);
             mBoundForBackgroundPeriod = null;
         }
     }
 
@@ skipping 18 matching lines @@
         if (managedConnection != null) managedConnection.clearConnection();
     }
 
     /** @return true iff the connection reference is no longer held */
     @VisibleForTesting
     public boolean isConnectionCleared(int pid) {
         synchronized (mManagedConnections) {
             return mManagedConnections.get(pid).isConnectionCleared();
         }
     }
+
+    @Override
+    public void startModerateBindingManagement(
+            Context context, int maxSize, float lowReduceRatio, float highReduceRatio) {
+        if (mIsLowMemoryDevice || mModerateBindingPool != null) return;
+
+        Log.i(TAG, "Moderate binding enabled: maxSize=" + maxSize + " lowReduceRatio="
+                        + lowReduceRatio + " highReduceRatio=" + highReduceRatio);
+        mModerateBindingPool = new ModerateBindingPool(maxSize, lowReduceRatio, highReduceRatio);
+        if (context != null) context.registerComponentCallbacks(mModerateBindingPool);
+    }
 }