Refactoring: Make IPC::Channel::TakeClientFileDescriptor() a ScopedFD.

content/browser/child_process_launcher.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/browser/child_process_launcher.h"
 
 #include <utility>  // For std::pair.
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 70 matching lines @@
       int child_process_id,
       Client* client) {
     client_ = client;
 
     CHECK(BrowserThread::GetCurrentThreadIdentifier(&client_thread_id_));
 
 #if defined(OS_ANDROID)
     // We need to close the client end of the IPC channel to reliably detect
     // child termination. We will close this fd after we create the child
     // process which is asynchronous on Android.
-    ipcfd_ = delegate->GetIpcFd();
+    ipcfd_.reset(delegate->TakeIpcFd().release());
 #endif
     BrowserThread::PostTask(
         BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
         base::Bind(
             &Context::LaunchInternal,
             make_scoped_refptr(this),
             client_thread_id_,
             child_process_id,
             delegate,
             cmd_line));
@@ skipping 69 matching lines @@
       // |this_object| is NOT thread safe. Only use it to post a task back.
       scoped_refptr<Context> this_object,
       BrowserThread::ID client_thread_id,
       int child_process_id,
       SandboxedProcessLauncherDelegate* delegate,
       base::CommandLine* cmd_line) {
     scoped_ptr<SandboxedProcessLauncherDelegate> delegate_deleter(delegate);
 #if defined(OS_WIN)
     bool launch_elevated = delegate->ShouldLaunchElevated();
 #elif defined(OS_ANDROID)
-    int ipcfd = delegate->GetIpcFd();
+    // Uses |ipcfd_| instead of |ipcfd| on Android.
 #elif defined(OS_MACOSX)
     base::EnvironmentMap env = delegate->GetEnvironment();
-    int ipcfd = delegate->GetIpcFd();
+    base::ScopedFD ipcfd = delegate->TakeIpcFd();
 #elif defined(OS_POSIX)
     bool use_zygote = delegate->ShouldUseZygote();
     base::EnvironmentMap env = delegate->GetEnvironment();
-    int ipcfd = delegate->GetIpcFd();
+    base::ScopedFD ipcfd = delegate->TakeIpcFd();
 #endif
     scoped_ptr<base::CommandLine> cmd_line_deleter(cmd_line);
     base::TimeTicks begin_launch_time = base::TimeTicks::Now();
 
 #if defined(OS_WIN)
     base::ProcessHandle handle = base::kNullProcessHandle;
     if (launch_elevated) {
       base::LaunchOptions options;
       options.start_hidden = true;
       base::LaunchElevatedProcess(*cmd_line, options, &handle);
     } else {
       handle = StartSandboxedProcess(delegate, cmd_line);
     }
 #elif defined(OS_POSIX)
     std::string process_type =
         cmd_line->GetSwitchValueASCII(switches::kProcessType);
     scoped_ptr<FileDescriptorInfo> files_to_register(
         FileDescriptorInfoImpl::Create());
-    files_to_register->Share(kPrimaryIPCChannel, ipcfd);
+
+#if defined(OS_ANDROID)
+    files_to_register->Share(kPrimaryIPCChannel, this_object->ipcfd_.get());
+#else
+    files_to_register->Transfer(kPrimaryIPCChannel, ipcfd.Pass());
+#endif
     base::StatsTable* stats_table = base::StatsTable::current();
     if (stats_table &&
         base::SharedMemory::IsHandleValid(
             stats_table->GetSharedMemoryHandle())) {
       base::FileDescriptor fd = stats_table->GetSharedMemoryHandle();
       DCHECK(!fd.auto_close);
       files_to_register->Share(kStatsTableSharedMemFd, fd.fd);
     }
 #endif
 
@@ skipping 11 matching lines @@
         files_to_register.Pass(),
         base::Bind(&ChildProcessLauncher::Context::OnChildProcessStarted,
                    this_object,
                    client_thread_id,
                    begin_launch_time));
 
 #elif defined(OS_POSIX)
     base::ProcessHandle handle = base::kNullProcessHandle;
     // We need to close the client end of the IPC channel to reliably detect
     // child termination.
-    base::ScopedFD ipcfd_closer(ipcfd);
 
 #if !defined(OS_MACOSX)
     GetContentClient()->browser()->GetAdditionalMappedFilesForChildProcess(
         *cmd_line, child_process_id, files_to_register.get());
     if (use_zygote) {
       handle = ZygoteHostImpl::GetInstance()->ForkRequest(
           cmd_line->argv(), files_to_register.Pass(), process_type);
     } else
     // Fall through to the normal posix case below when we're not zygoting.
 #endif  // !defined(OS_MACOSX)
@@ skipping 77 matching lines @@
 #endif  // !defined(OS_ANDROID)
   }
 
   void Notify(
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
       bool zygote,
 #endif
       base::ProcessHandle handle) {
 #if defined(OS_ANDROID)
     // Finally close the ipcfd
-    base::ScopedFD ipcfd_closer(ipcfd_);
+    base::ScopedFD ipcfd_closer = ipcfd_.Pass();
 #endif
     starting_ = false;
     process_.set_handle(handle);
     if (!handle)
       LOG(ERROR) << "Failed to launch child process";
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
     zygote_ = zygote;
 #endif
     if (client_) {
@@ skipping 70 matching lines @@
   BrowserThread::ID client_thread_id_;
   base::Process process_;
   base::TerminationStatus termination_status_;
   int exit_code_;
   bool starting_;
   // Controls whether the child process should be terminated on browser
   // shutdown. Default behavior is to terminate the child.
   bool terminate_child_on_shutdown_;
 #if defined(OS_ANDROID)
   // The fd to close after creating the process.
-  int ipcfd_;
+  base::ScopedFD ipcfd_;
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
   bool zygote_;
 #endif
 };
 
 
 ChildProcessLauncher::ChildProcessLauncher(
     SandboxedProcessLauncherDelegate* delegate,
     base::CommandLine* cmd_line,
     int child_process_id,
@@ skipping 76 matching lines @@
          GetHandle(), background));
 }
 
 void ChildProcessLauncher::SetTerminateChildOnShutdown(
     bool terminate_on_shutdown) {
   if (context_.get())
     context_->set_terminate_child_on_shutdown(terminate_on_shutdown);
 }
 
 }  // namespace content