Close leaking FDs.

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

 // Copyright (c) 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.os.RemoteException;
 import android.util.Log;
 import android.view.Surface;
@@ skipping 143 matching lines @@
     }
 
     /**
      * Spawns and connects to a sandboxed process. May be called on any thread. It will not
      * block, but will instead callback to {@link #nativeOnSandboxedProcessStarted} when the
      * connection is established. Note this callback will not necessarily be from the same thread
      * (currently it always comes from the main thread).
      *
      * @param context Context used to obtain the application context.
      * @param commandLine The sandboxed process command line argv.
-     * @param ipcFd File descriptor used to set up IPC.
+     * @param file_ids The ID that should be used when mapping files in the created process.
+     * @param file_fds The file descriptors that should be mapped in the created process.
+     * @param file_autoclose Whether the file descriptors should be closed once they were passed to
+     * the created process.
      * @param clientContext Arbitrary parameter used by the client to distinguish this connection.
      */
     @CalledByNative
     static void start(
             Context context,
             final String[] commandLine,
-            int ipcFd,
-            int[] fileToRegisterIdFds,
+            int[] file_ids,
+            int[] file_fds,
+            boolean[] file_autoclose,
             final int clientContext) {
+        assert file_ids.length == file_fds.length && file_fds.length == file_autoclose.length;
+        FileDescriptorInfo[] filesToBeMapped = new FileDescriptorInfo[file_fds.length];
+        for (int i = 0; i < file_fds.length; i++) {
+            filesToBeMapped[i] =
+                    new FileDescriptorInfo(file_ids[i], file_fds[i], file_autoclose[i]);
+        }
         assert clientContext != 0;
         SandboxedProcessConnection allocatedConnection;
         synchronized (SandboxedProcessLauncher.class) {
             allocatedConnection = mSpareConnection;
             mSpareConnection = null;
         }
         if (allocatedConnection == null) {
             allocatedConnection = allocateBoundConnection(context, commandLine);
             if (allocatedConnection == null) {
                 // Notify the native code so it can free the heap allocated callback.
@@ skipping 10 matching lines @@
                 final int pid = connection.getPid();
                 Log.d(TAG, "on connect callback, pid=" + pid + " context=" + clientContext);
                 if (pid != NULL_PROCESS_HANDLE) {
                     mServiceMap.put(pid, connection);
                 } else {
                     freeConnection(connection);
                 }
                 nativeOnSandboxedProcessStarted(clientContext, pid);
             }
         };
-        connection.setupConnection(commandLine, ipcFd, fileToRegisterIdFds, createCallback(),
-                onConnect);
+        connection.setupConnection(commandLine, filesToBeMapped, createCallback(), onConnect);
     }
 
     /**
      * Terminates a sandboxed 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 sandboxed connection: pid=" + pid);
@@ skipping 76 matching lines @@
                 // avoid waiting for the finalizer to get around to it.
                 if (surface != null) {
                     surface.release();
                 }
             }
         };
     };
 
     private static native void nativeOnSandboxedProcessStarted(int clientContext, int pid);
 }