Merging Managed and Important connection.

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.content.ComponentCallbacks2;
 import android.content.Context;
 import android.content.res.Configuration;
 import android.util.SparseArray;
@@ skipping 159 matching lines @@
             if (mDelayedClearer != null) {
                 LauncherThread.removeCallbacks(mDelayedClearer);
                 mDelayedClearer = null;
             }
         }
     }
 
     private ModerateBindingPool mModerateBindingPool;
 
     /**
-     * Wraps ManagedChildProcessConnection keeping track of additional information needed to manage
-     * the bindings of the connection. It goes away when the connection goes away.
+     * Wraps ChildProcessConnection keeping track of additional information needed to manage the
+     * bindings of the connection. It goes away when the connection goes away.
      */
     private class ManagedConnection {
         // The connection to the service.
-        private final ManagedChildProcessConnection mConnection;
+        private final ChildProcessConnection mConnection;
 
         // True iff there is a strong binding kept on the service because it is working in
         // foreground.
         private boolean mInForeground;
 
         // Indicates there's a pending view in this connection that's about to become foreground.
         // This currently maps exactly to the initial binding.
         private boolean mBoostPriorityForPendingViews = true;
 
         // True iff there is a strong binding kept on the service because it was bound for the
@@ skipping 31 matching lines @@
             } else {
                 LauncherThread.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) {
+        private void addConnectionToModerateBindingPool(ChildProcessConnection connection) {
             if (mModerateBindingPool != null && !connection.isStrongBindingBound()) {
                 mModerateBindingPool.addConnection(ManagedConnection.this);
             }
         }
 
         /** Removes the moderate service binding. */
         private void removeModerateBinding() {
             if (!mConnection.isModerateBindingBound()) return;
             mConnection.removeModerateBinding();
         }
 
         /** Adds the moderate service binding. */
         private void addModerateBinding() {
             mConnection.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;
             mConnection.dropOomBindings();
         }
 
-        ManagedConnection(ManagedChildProcessConnection connection) {
+        ManagedConnection(ChildProcessConnection connection) {
             mConnection = connection;
         }
 
         /**
          * Sets the visibility of the service, adding or removing the strong binding as needed.
          */
         void setPriority(boolean foreground, boolean boostForPendingViews) {
             // Always add bindings before removing them.
             if (!mInForeground && foreground) {
                 addStrongBinding();
@@ skipping 64 matching lines @@
      * 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);
     }
 
     @Override
-    public void addNewConnection(int pid, ManagedChildProcessConnection connection) {
+    public void addNewConnection(int pid, ChildProcessConnection connection) {
         assert LauncherThread.runningOnLauncherThread();
         // 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 setPriority(int pid, boolean foreground, boolean boostForPendingViews) {
         assert LauncherThread.runningOnLauncherThread();
         ManagedConnection managedConnection = mManagedConnections.get(pid);
@@ skipping 75 matching lines @@
 
     @Override
     public void releaseAllModerateBindings() {
         assert LauncherThread.runningOnLauncherThread();
         if (mModerateBindingPool != null) {
             Log.i(TAG, "Release all moderate bindings: %d", mModerateBindingPool.size());
             mModerateBindingPool.removeAllConnections();
         }
     }
 }