Refactor configuration of sandboxes - first steps

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"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_descriptors.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
+#include "content/public/common/sandboxed_process_launcher_delegate.h"
 
 #if defined(OS_WIN)
 #include "base/files/file_path.h"
 #include "content/common/sandbox_win.h"
 #include "content/public/common/sandbox_init.h"
-#include "content/public/common/sandboxed_process_launcher_delegate.h"
 #elif defined(OS_MACOSX)
 #include "content/browser/mach_broker_mac.h"
 #elif defined(OS_ANDROID)
 #include "base/android/jni_android.h"
 #include "content/browser/android/child_process_launcher_android.h"
 #elif defined(OS_POSIX)
 #include "base/memory/shared_memory.h"
 #include "base/memory/singleton.h"
 #include "content/browser/renderer_host/render_sandbox_host_linux.h"
 #include "content/browser/zygote_host/zygote_host_impl_linux.h"
@@ skipping 25 matching lines @@
         {
 #if defined(OS_POSIX)
           terminate_child_on_shutdown_ = !CommandLine::ForCurrentProcess()->
               HasSwitch(switches::kChildCleanExit);
 #else
           terminate_child_on_shutdown_ = true;
 #endif
   }
 
   void Launch(
-#if defined(OS_WIN)
       SandboxedProcessLauncherDelegate* delegate,
-      bool launch_elevated,
-#elif defined(OS_ANDROID)
-      int ipcfd,
-#elif defined(OS_POSIX)
-      bool use_zygote,
-      const base::EnvironmentMap& environ,
-      int ipcfd,
-#endif
       CommandLine* cmd_line,
       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_ = ipcfd;
+    ipcfd_ = delegate->IpcFd();
 #endif
     BrowserThread::PostTask(
         BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
         base::Bind(
             &Context::LaunchInternal,
             make_scoped_refptr(this),
             client_thread_id_,
             child_process_id,
-#if defined(OS_WIN)
             delegate,
-            launch_elevated,
-#elif defined(OS_ANDROID)
-            ipcfd,
-#elif defined(OS_POSIX)
-            use_zygote,
-            environ,
-            ipcfd,
-#endif
             cmd_line));
   }
 
 #if defined(OS_ANDROID)
   static void OnChildProcessStarted(
       // |this_object| is NOT thread safe. Only use it to post a task back.
       scoped_refptr<Context> this_object,
       BrowserThread::ID client_thread_id,
       const base::TimeTicks begin_launch_time,
       base::ProcessHandle handle) {
@@ skipping 54 matching lines @@
       UMA_HISTOGRAM_TIMES("MPArch.ChildProcessLaunchFirst", launch_time);
       done_first_launch = true;
     }
   }
 
   static void LaunchInternal(
       // |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,
+      CommandLine* cmd_line) {
 #if defined(OS_WIN)
-      SandboxedProcessLauncherDelegate* delegate,
-      bool launch_elevated,
+    bool launch_elevated = delegate -> LaunchElevated();

[jam, 2014/02/26 19:47:52]

nit: no space

[aberent, 2014/02/28 08:51:06]

Done.

 #elif defined(OS_ANDROID)
-      int ipcfd,
+    int ipcfd = delegate->IpcFd();
+#elif defined(OS_MACOSX)
+    base::EnvironmentMap env = delegate->GetEnvironment();
+    int ipcfd = delegate->IpcFd();
 #elif defined(OS_POSIX)
-      bool use_zygote,
-      const base::EnvironmentMap& env,
-      int ipcfd,
+    bool use_zygote = delegate->UseZygote();
+    base::EnvironmentMap env = delegate->GetEnvironment();
+    int ipcfd = delegate->IpcFd();
 #endif
-      CommandLine* cmd_line) {
     scoped_ptr<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 {
@@ skipping 214 matching lines @@
 #if defined(OS_ANDROID)
   // The fd to close after creating the process.
   int ipcfd_;
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
   bool zygote_;
 #endif
 };
 
 
 ChildProcessLauncher::ChildProcessLauncher(
-#if defined(OS_WIN)
     SandboxedProcessLauncherDelegate* delegate,
-    bool launch_elevated,
-#elif defined(OS_POSIX)
-    bool use_zygote,
-    const base::EnvironmentMap& environ,
-    int ipcfd,
-#endif
     CommandLine* cmd_line,
     int child_process_id,
     Client* client) {
   context_ = new Context();
   context_->Launch(
-#if defined(OS_WIN)
       delegate,
-      launch_elevated,
-#elif defined(OS_ANDROID)
-      ipcfd,
-#elif defined(OS_POSIX)
-      use_zygote,
-      environ,
-      ipcfd,
-#endif
       cmd_line,
       child_process_id,
       client);
 }
 
 ChildProcessLauncher::~ChildProcessLauncher() {
   context_->ResetClient();
 }
 
 bool ChildProcessLauncher::IsStarting() {
@@ skipping 62 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