Android: distinguish between crashes and out-of-memory kills in content

content/public/android/java/src/org/chromium/content/browser/ChildProcessLauncher.java

 // Copyright 2012 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.Context;
 import android.util.Log;
+import android.util.SparseIntArray;
 import android.view.Surface;
 
 import java.util.ArrayList;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 import org.chromium.base.ThreadUtils;
 import org.chromium.content.app.ChildProcessService;
@@ skipping 148 matching lines @@
         return;
     }
 
     // Represents an invalid process handle; same as base/process/process.h kNullProcessHandle.
     private static final int NULL_PROCESS_HANDLE = 0;
 
     // Map from pid to ChildService connection.
     private static Map<Integer, ChildProcessConnection> mServiceMap =
             new ConcurrentHashMap<Integer, ChildProcessConnection>();
 
+    // Map from pid to the count of oom bindings. "Oom binding" is a binding that raises the process
+    // oom priority so that it shouldn't be killed by the OS out-of-memory killer under normal
+    // conditions (it can still be killed under drastic memory pressure).
+    private static SparseIntArray sOomBindingCount = new SparseIntArray();
+
     // A pre-allocated and pre-bound connection ready for connection setup, or null.
     static ChildProcessConnection mSpareSandboxedConnection = null;
 
     /**
      * Returns the child process service interface for the given pid. This may be called on
      * any thread, but the caller must assume that the service can disconnect at any time. All
      * service calls should catch and handle android.os.RemoteException.
      *
      * @param pid The pid (process handle) of the service obtained from {@link #start}.
      * @return The IChildProcessService or null if the service no longer exists.
@@ skipping 86 matching lines @@
         if (allocatedConnection == null) {
             allocatedConnection = allocateBoundConnection(context, commandLine, inSandbox);
             if (allocatedConnection == null) {
                 // Notify the native code so it can free the heap allocated callback.
                 nativeOnChildProcessStarted(clientContext, 0);
                 return;
             }
         }
         final ChildProcessConnection connection = allocatedConnection;
         Log.d(TAG, "Setting up connection to process: slot=" + connection.getServiceNumber());
-        // Note: This runnable will be executed when the child connection is setup.
-        final Runnable onConnect = new Runnable() {
-            @Override
-            public void run() {
-                final int pid = connection.getPid();
+
+        ChildProcessConnection.ConnectionCallbacks connectionCallbacks =
+                new ChildProcessConnection.ConnectionCallbacks() {
+            public void onConnected(int pid, int oomBindingCount) {
                 Log.d(TAG, "on connect callback, pid=" + pid + " context=" + clientContext);
                 if (pid != NULL_PROCESS_HANDLE) {
+                    sOomBindingCount.put(pid, oomBindingCount);
                     mServiceMap.put(pid, connection);
                 } else {
                     freeConnection(connection);
                 }
                 nativeOnChildProcessStarted(clientContext, pid);
             }
+
+            public void onOomBindingAdded(int pid) {
+                if (pid != NULL_PROCESS_HANDLE) {
+                    sOomBindingCount.put(pid, sOomBindingCount.get(pid) + 1);
+                }
+            }
+
+            public void onOomBindingRemoved(int pid) {
+                if (pid != NULL_PROCESS_HANDLE) {
+                    int count = sOomBindingCount.get(pid, -1);
+                    assert count > 0;
+                    count--;
+                    if (count > 0) {
+                        sOomBindingCount.put(pid, count);
+                    } else {
+                        sOomBindingCount.delete(pid);
+                    }
+                }
+            }
         };
+
         // TODO(sievers): Revisit this as it doesn't correctly handle the utility process
         // assert callbackType != CALLBACK_FOR_UNKNOWN_PROCESS;
 
-        connection.setupConnection(
-                commandLine, filesToBeMapped, createCallback(callbackType), onConnect);
+        connection.setupConnection(commandLine, filesToBeMapped, createCallback(callbackType),
+                connectionCallbacks);
     }
 
     /**
      * Terminates a child process. This may be called from any thread.
      *
      * @param pid The pid (process handle) of the service connection obtained from {@link #start}.
      */
     @CalledByNative
     static void stop(int pid) {
         Log.d(TAG, "stopping child connection: pid=" + pid);
@@ skipping 44 matching lines @@
     static void unbindAsHighPriority(int pid) {
         ChildProcessConnection connection = mServiceMap.get(pid);
         if (connection == null) {
             LogPidWarning(pid, "Tried to unbind non-existent connection");
             return;
         }
         connection.detachAsActive();
     }
 
     /**
+     * @return True iff the given service process is protected from the out-of-memory killing, or it
+     * was protected from it when it died.
+     */
+    public static boolean isOomProtected(int pid) {
+        return sOomBindingCount.get(pid) > 0;
+    }
+
+    /**
      * This implementation is used to receive callbacks from the remote service.
      */
     private static IChildProcessCallback createCallback(final int callbackType) {
         return new IChildProcessCallback.Stub() {
             /**
              * This is called by the remote service regularly to tell us about new values. Note that
              * IPC calls are dispatched through a thread pool running in each process, so the code
              * executing here will NOT be running in our main thread -- so, to update the UI, we
              * need to use a Handler.
              */
@@ skipping 29 matching lines @@
             Log.w(TAG, message + ", pid=" + pid);
         }
     }
 
     private static native void nativeOnChildProcessStarted(int clientContext, int pid);
     private static native Surface nativeGetViewSurface(int surfaceId);
     private static native void nativeEstablishSurfacePeer(
             int pid, Surface surface, int primaryID, int secondaryID);
     private static native boolean nativeIsSingleProcess();
 }