Introduce moderate binding

content/public/android/java/src/org/chromium/content/browser/ChildProcessConnectionImpl.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.content.browser;
 
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.os.Bundle;
 import android.os.DeadObjectException;
 import android.os.IBinder;
 import android.os.RemoteException;
-import android.util.Log;
 
 import org.chromium.base.CpuFeatures;
+import org.chromium.base.Log;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.TraceEvent;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.library_loader.Linker;
 import org.chromium.content.app.ChildProcessService;
 import org.chromium.content.app.ChromiumLinkerParams;
 import org.chromium.content.common.IChildProcessCallback;
 import org.chromium.content.common.IChildProcessService;
 
 import java.io.IOException;
@@ skipping 28 matching lines @@
     // Strong binding will make the service priority equal to the priority of the activity. We want
     // the OS to be able to kill background renderers as it kills other background apps, so strong
     // bindings are maintained only for services that are active at the moment (between
     // addStrongBinding() and removeStrongBinding()).
     private ChildServiceConnection mStrongBinding = null;
     // Low priority binding maintained in the entire lifetime of the connection, i.e. between calls
     // to start() and stop().
     private ChildServiceConnection mWaivedBinding = null;
     // Incremented on addStrongBinding(), decremented on removeStrongBinding().
     private int mStrongBindingCount = 0;
+    // Moderate binding will make the service priority equal to the priority of a visible process
+    // while the app is in the foreground. It will stay bound only while the app is in the
+    // foreground to protect a background process from the system out-of-memory killer.
+    private ChildServiceConnection mModerateBinding = null;
 
     // Linker-related parameters.
     private ChromiumLinkerParams mLinkerParams = null;
 
     private final boolean mAlwaysInForeground;
 
-    private static final String TAG = "ChildProcessConnection";
+    private static final String TAG = "cr.ChildProcessConnect";
 
     private static class ConnectionParams {
         final String[] mCommandLine;
         final FileDescriptorInfo[] mFilesToBeMapped;
         final IChildProcessCallback mCallback;
         final Bundle mSharedRelros;
 
         ConnectionParams(String[] commandLine, FileDescriptorInfo[] filesToBeMapped,
                 IChildProcessCallback callback, Bundle sharedRelros) {
             mCommandLine = commandLine;
@@ skipping 122 matching lines @@
         mServiceClass = serviceClass;
         mLinkerParams = chromiumLinkerParams;
         mAlwaysInForeground = alwaysInForeground;
         int initialFlags = Context.BIND_AUTO_CREATE;
         if (mAlwaysInForeground) initialFlags |= Context.BIND_IMPORTANT;
         mInitialBinding = new ChildServiceConnection(initialFlags);
         mStrongBinding = new ChildServiceConnection(
                 Context.BIND_AUTO_CREATE | Context.BIND_IMPORTANT);
         mWaivedBinding = new ChildServiceConnection(
                 Context.BIND_AUTO_CREATE | Context.BIND_WAIVE_PRIORITY);
+        mModerateBinding = new ChildServiceConnection(Context.BIND_AUTO_CREATE);
     }
 
     @Override
     public int getServiceNumber() {
         return mServiceNumber;
     }
 
     @Override
     public boolean isInSandbox() {
         return mInSandbox;
@@ skipping 65 matching lines @@
             }
         }
     }
 
     @Override
     public void stop() {
         synchronized (mLock) {
             mInitialBinding.unbind();
             mStrongBinding.unbind();
             mWaivedBinding.unbind();
+            mModerateBinding.unbind();
             mStrongBindingCount = 0;
             if (mService != null) {
                 mService = null;
             }
             mConnectionParams = null;
         }
     }
 
     /**
      * Called after the connection parameters have been set (in setupConnection()) *and* a
@@ skipping 81 matching lines @@
     }
 
     @Override
     public void dropOomBindings() {
         synchronized (mLock) {
             assert !mAlwaysInForeground;
             mInitialBinding.unbind();
 
             mStrongBindingCount = 0;
             mStrongBinding.unbind();
+
+            mModerateBinding.unbind();
         }
     }
 
     @Override
     public void addStrongBinding() {
         synchronized (mLock) {
             if (mService == null) {
                 Log.w(TAG, "The connection is not bound for " + mPid);
                 return;
             }
@@ skipping 12 matching lines @@
                 return;
             }
             assert mStrongBindingCount > 0;
             mStrongBindingCount--;
             if (mStrongBindingCount == 0) {
                 mStrongBinding.unbind();
             }
         }
     }
 
+    @Override
+    public boolean isModerateBindingBound() {
+        synchronized (mLock) {
+            return mModerateBinding.isBound();
+        }
+    }
+
+    @Override
+    public void addModerateBinding() {
+        synchronized (mLock) {
+            if (mService == null) {
+                Log.w(TAG, "The connection is not bound for " + mPid);
+                return;
+            }
+            mModerateBinding.bind(null);
+        }
+    }
+
+    @Override
+    public void removeModerateBinding() {
+        synchronized (mLock) {
+            if (mService == null) {
+                Log.w(TAG, "The connection is not bound for " + mPid);
+                return;
+            }
+            mModerateBinding.unbind();
+        }
+    }
+
     @VisibleForTesting
     public boolean crashServiceForTesting() throws RemoteException {
         try {
             mService.crashIntentionallyForTesting();
         } catch (DeadObjectException e) {
             return true;
         }
         return false;
     }
 
     @VisibleForTesting
     public boolean isConnected() {
         return mService != null;
     }
 }