Close leaking FDs.

content/app/android/sandboxed_process_service.cc

 // 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.
 
 #include "content/app/android/sandboxed_process_service.h"
 
 #include "base/android/jni_array.h"
 #include "base/global_descriptors_posix.h"
 #include "base/logging.h"
 #include "content/common/android/surface_texture_peer.h"
@@ skipping 32 matching lines @@
 
  private:
   // The instance of org.chromium.content.app.SandboxedProcessService.
   jobject service_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceTexturePeerSandboxedImpl);
 };
 
 // Chrome actually uses the renderer code path for all of its sandboxed
 // processes such as renderers, plugins, etc.
-void InternalInitSandboxedProcess(int ipc_fd,
-                                  const std::vector<int>& extra_file_ids,
-                                  const std::vector<int>& extra_file_fds,
+void InternalInitSandboxedProcess(const std::vector<int>& file_ids,
+                                  const std::vector<int>& file_fds,
                                   JNIEnv* env,
                                   jclass clazz,
                                   jobject context,
                                   jobject service) {
-  // Set up the IPC file descriptor mapping.
-  base::GlobalDescriptors::GetInstance()->Set(kPrimaryIPCChannel, ipc_fd);
-  // Register the extra file descriptors.
-  // This usually include the crash dump signals and resource related files.
-  DCHECK(extra_file_fds.size() == extra_file_ids.size());
-  for (size_t i = 0; i < extra_file_ids.size(); ++i) {
-    base::GlobalDescriptors::GetInstance()->Set(extra_file_ids[i],
-                                                extra_file_fds[i]);
-  }
+  // Register the file descriptors.
+  // This includes the IPC channel, the crash dump signals and resource related
+  // files.
+  DCHECK(file_fds.size() == file_ids.size());
+  for (size_t i = 0; i < file_ids.size(); ++i)
+    base::GlobalDescriptors::GetInstance()->Set(file_ids[i], file_fds[i]);
 
   content::SurfaceTexturePeer::InitInstance(
       new SurfaceTexturePeerSandboxedImpl(service));
 
 }
 
 }  // namespace <anonymous>
 
 namespace content {
 
 void InitSandboxedProcess(JNIEnv* env,
                           jclass clazz,
                           jobject context,
                           jobject service,
-                          jint ipc_fd,
-                          jintArray j_extra_file_ids,
-                          jintArray j_extra_file_fds) {
-  std::vector<int> extra_file_ids;
-  std::vector<int> extra_file_fds;
-  JavaIntArrayToIntVector(env, j_extra_file_ids, &extra_file_ids);
-  JavaIntArrayToIntVector(env, j_extra_file_fds, &extra_file_fds);
+                          jintArray j_file_ids,
+                          jintArray j_file_fds) {
+  std::vector<int> file_ids;
+  std::vector<int> file_fds;
+  JavaIntArrayToIntVector(env, j_file_ids, &file_ids);
+  JavaIntArrayToIntVector(env, j_file_fds, &file_fds);
 
-  InternalInitSandboxedProcess(static_cast<int>(ipc_fd),
-                               extra_file_ids, extra_file_fds,
-                               env, clazz, context, service);
+  InternalInitSandboxedProcess(
+      file_ids, file_fds, env, clazz, context, service);
 }
 
 void ExitSandboxedProcess(JNIEnv* env, jclass clazz) {
   LOG(INFO) << "SandboxedProcessService: Exiting sandboxed process.";
   LibraryLoaderExitHook();
   _exit(0);
 }
 
 bool RegisterSandboxedProcessService(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content