Remove obsolete methods from IPC::Channel and related classes.

content/browser/child_process_launcher.cc

 // 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.
 
 #include "content/browser/child_process_launcher.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 49 matching lines @@
 #include "gin/v8_initializer.h"
 #endif
 
 namespace content {
 
 namespace {
 
 typedef base::Callback<void(ZygoteHandle,
 #if defined(OS_ANDROID)
                             base::ScopedFD,
-                            base::ScopedFD,
 #endif
                             base::Process,
-                            int)> NotifyCallback;
+                            int)>
+    NotifyCallback;
 
 void RecordHistogramsOnLauncherThread(base::TimeDelta launch_time) {
   DCHECK_CURRENTLY_ON(BrowserThread::PROCESS_LAUNCHER);
   // Log the launch time, separating out the first one (which will likely be
   // slower due to the rest of the browser initializing at the same time).
   static bool done_first_launch = false;
   if (done_first_launch) {
     UMA_HISTOGRAM_TIMES("MPArch.ChildProcessLaunchSubsequent", launch_time);
   } else {
     UMA_HISTOGRAM_TIMES("MPArch.ChildProcessLaunchFirst", launch_time);
     done_first_launch = true;
   }
 }
 
 #if defined(OS_ANDROID)
 // TODO(sievers): Remove this by defining better what happens on what
 // thread in the corresponding Java code.
 void OnChildProcessStartedAndroid(const NotifyCallback& callback,
                                   BrowserThread::ID client_thread_id,
                                   const base::TimeTicks begin_launch_time,
-                                  base::ScopedFD ipcfd,
                                   base::ScopedFD mojo_fd,
                                   base::ProcessHandle handle) {
   int launch_result = (handle == base::kNullProcessHandle)
                           ? LAUNCH_RESULT_FAILURE
                           : LAUNCH_RESULT_SUCCESS;
   // This can be called on the launcher thread or UI thread.
   base::TimeDelta launch_time = base::TimeTicks::Now() - begin_launch_time;
   BrowserThread::PostTask(
       BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
       base::Bind(&RecordHistogramsOnLauncherThread, launch_time));
 
-  base::Closure callback_on_client_thread(base::Bind(
-      callback, nullptr, base::Passed(&ipcfd), base::Passed(&mojo_fd),
-      base::Passed(base::Process(handle)), launch_result));
+  base::Closure callback_on_client_thread(
+      base::Bind(callback, nullptr, base::Passed(&mojo_fd),
+                 base::Passed(base::Process(handle)), launch_result));
   if (BrowserThread::CurrentlyOn(client_thread_id)) {
     callback_on_client_thread.Run();
   } else {
     BrowserThread::PostTask(
         client_thread_id, FROM_HERE, callback_on_client_thread);
   }
 }
 #endif
 
 void LaunchOnLauncherThread(const NotifyCallback& callback,
                             BrowserThread::ID client_thread_id,
                             int child_process_id,
                             SandboxedProcessLauncherDelegate* delegate,
-#if defined(OS_ANDROID)
-                            base::ScopedFD ipcfd,
-#endif
                             mojo::edk::ScopedPlatformHandle client_handle,
                             base::CommandLine* cmd_line) {
   DCHECK_CURRENTLY_ON(BrowserThread::PROCESS_LAUNCHER);
   std::unique_ptr<SandboxedProcessLauncherDelegate> delegate_deleter(delegate);
 #if !defined(OS_ANDROID)
   ZygoteHandle zygote = nullptr;
   int launch_result = LAUNCH_RESULT_FAILURE;
 #endif
 #if defined(OS_WIN)
   bool launch_elevated = delegate->ShouldLaunchElevated();
 #elif defined(OS_MACOSX)
   base::EnvironmentMap env = delegate->GetEnvironment();
-  base::ScopedFD ipcfd = delegate->TakeIpcFd();
 #elif defined(OS_POSIX) && !defined(OS_ANDROID)
   base::EnvironmentMap env = delegate->GetEnvironment();
-  base::ScopedFD ipcfd = delegate->TakeIpcFd();
 #endif
   std::unique_ptr<base::CommandLine> cmd_line_deleter(cmd_line);
   base::TimeTicks begin_launch_time = base::TimeTicks::Now();
 
   base::Process process;
 #if defined(OS_WIN)
   if (launch_elevated) {
     // When establishing a Mojo connection, the pipe path has already been added
     // to the command line.
     base::LaunchOptions options;
@@ skipping 12 matching lines @@
 #elif defined(OS_POSIX)
   std::string process_type =
       cmd_line->GetSwitchValueASCII(switches::kProcessType);
   std::unique_ptr<FileDescriptorInfo> files_to_register(
       FileDescriptorInfoImpl::Create());
 
   base::ScopedFD mojo_fd(client_handle.release().handle);
   DCHECK(mojo_fd.is_valid());
 
 #if defined(OS_ANDROID)
-  if (ipcfd.get() != -1)
-    files_to_register->Share(kPrimaryIPCChannel, ipcfd.get());
   files_to_register->Share(kMojoIPCChannel, mojo_fd.get());
 #else
-  if (ipcfd.get() != -1)
-    files_to_register->Transfer(kPrimaryIPCChannel, std::move(ipcfd));
   files_to_register->Transfer(kMojoIPCChannel, std::move(mojo_fd));
 #endif
 #endif
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   std::map<int, base::MemoryMappedFile::Region> regions;
   GetContentClient()->browser()->GetAdditionalMappedFilesForChildProcess(
       *cmd_line, child_process_id, files_to_register.get()
 #if defined(OS_ANDROID)
       , &regions
@@ skipping 57 matching lines @@
       base::i18n::GetIcuDataFileHandle(&regions[kAndroidICUDataDescriptor]));
 #endif  // ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
 
   // Android WebView runs in single process, ensure that we never get here
   // when running in single process mode.
   CHECK(!cmd_line->HasSwitch(switches::kSingleProcess));
 
   StartChildProcess(
       cmd_line->argv(), child_process_id, std::move(files_to_register), regions,
       base::Bind(&OnChildProcessStartedAndroid, callback, client_thread_id,
-                 begin_launch_time, base::Passed(&ipcfd),
-                 base::Passed(&mojo_fd)));
+                 begin_launch_time, base::Passed(&mojo_fd)));
 
 #elif defined(OS_POSIX)
   // We need to close the client end of the IPC channel to reliably detect
   // child termination.
 
 #if !defined(OS_MACOSX)
   ZygoteHandle* zygote_handle =
       !base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoZygote)
           ? delegate->GetZygote()
           : nullptr;
@@ skipping 179 matching lines @@
 #if defined(ENABLE_PLUGINS)
         process_type == switches::kPpapiPluginProcess ||
 #endif
         process_type == switches::kUtilityProcess)
       << "Unsupported process type: " << process_type;
 
   // Non-sandboxed utility or renderer process are currently not supported.
   DCHECK(process_type == switches::kGpuProcess ||
          !cmd_line->HasSwitch(switches::kNoSandbox));
 
-  // 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.
-  base::ScopedFD ipcfd(delegate->TakeIpcFd().release());
 #endif
   mojo::edk::ScopedPlatformHandle server_handle;
   mojo::edk::ScopedPlatformHandle client_handle;
 #if defined(OS_WIN)
   if (delegate->ShouldLaunchElevated()) {
     mojo::edk::NamedPlatformChannelPair named_pair;
     server_handle = named_pair.PassServerHandle();
     named_pair.PrepareToPassClientHandleToChildProcess(cmd_line);
   } else
 #endif
   {
     mojo::edk::PlatformChannelPair channel_pair;
     server_handle = channel_pair.PassServerHandle();
     client_handle = channel_pair.PassClientHandle();
   }
   NotifyCallback reply_callback(base::Bind(&ChildProcessLauncher::DidLaunch,
                                            weak_factory_.GetWeakPtr(),
                                            terminate_child_on_shutdown_,
                                            base::Passed(&server_handle)));
   BrowserThread::PostTask(
       BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
       base::Bind(&LaunchOnLauncherThread, reply_callback, client_thread_id_,
                  child_process_id, delegate,
-#if defined(OS_ANDROID)
-                 base::Passed(&ipcfd),
-#endif
                  base::Passed(&client_handle), cmd_line));
 }
 
 void ChildProcessLauncher::UpdateTerminationStatus(bool known_dead) {
   DCHECK(CalledOnValidThread());
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
   if (zygote_) {
     termination_status_ = zygote_->GetTerminationStatus(
         process_.Handle(), known_dead, &exit_code_);
   } else if (known_dead) {
@@ skipping 24 matching lines @@
                           base::Bind(&SetProcessBackgroundedOnLauncherThread,
                                      base::Passed(&to_pass), background));
 }
 
 void ChildProcessLauncher::DidLaunch(
     base::WeakPtr<ChildProcessLauncher> instance,
     bool terminate_on_shutdown,
     mojo::edk::ScopedPlatformHandle server_handle,
     ZygoteHandle zygote,
 #if defined(OS_ANDROID)
-    base::ScopedFD ipcfd,
     base::ScopedFD mojo_fd,
 #endif
     base::Process process,
     int error_code) {
   if (!process.IsValid())
     LOG(ERROR) << "Failed to launch child process";
 
   if (instance.get()) {
     instance->Notify(zygote, std::move(server_handle),
-#if defined(OS_ANDROID)
-                     std::move(ipcfd),
-#endif
                      std::move(process), error_code);
   } else {
     if (process.IsValid() && terminate_on_shutdown) {
       // On Posix, EnsureProcessTerminated can lead to 2 seconds of sleep!  So
       // don't this on the UI/IO threads.
       BrowserThread::PostTask(BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
                               base::Bind(&TerminateOnLauncherThread, zygote,
                                          base::Passed(&process)));
     }
   }
 }
 
 void ChildProcessLauncher::Notify(ZygoteHandle zygote,
                                   mojo::edk::ScopedPlatformHandle server_handle,
-#if defined(OS_ANDROID)
-                                  base::ScopedFD ipcfd,
-#endif
                                   base::Process process,
                                   int error_code) {
   DCHECK(CalledOnValidThread());
   starting_ = false;
   process_ = std::move(process);
 
   if (process_.IsValid()) {
     // Set up Mojo IPC to the new process.
     mojo::edk::ChildProcessLaunched(process_.Handle(), std::move(server_handle),
                                     mojo_child_token_, process_error_callback_);
@@ skipping 51 matching lines @@
 }
 
 ChildProcessLauncher::Client* ChildProcessLauncher::ReplaceClientForTest(
     Client* client) {
   Client* ret = client_;
   client_ = client;
   return ret;
 }
 
 }  // namespace content