Unify the sandboxed vs. unsandboxed code paths more, for two reasons:

content/browser/zygote_main_linux.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/zygote_host_impl_linux.h"
 
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <stdio.h>
@@ skipping 836 matching lines @@
   // pre-sandbox init, but more likely this is just a build configuration error.
   #error Which SSL library are you using?
 #endif
 
   // Ensure access to the Pepper plugins before the sandbox is turned on.
   PepperPluginRegistry::PreloadModules();
 }
 
 #if !defined(CHROMIUM_SELINUX)
 static bool EnterSandbox() {
+  PreSandboxInit();
+  SkiaFontConfigSetImplementation(
+      new FontConfigIPC(kMagicSandboxIPCDescriptor));
+

[Jorge Lucangeli Obes, 2012/04/16 19:59:28]

So this will do the pre-sandbox init even if the SUID sandbox is not enabled,
because we also need the pre-init for the new seccomp sandbox right?

Does SkiaFontConfigSetImplementation(new
FontConfigIPC(kMagicSandboxIPCDescriptor)) work when the SUID sandbox is not
enabled? Given that most tests in the trybots run without the SUID sandbox, the
green try run suggests it does, but no harm in testing explicitly.

   // The SUID sandbox sets this environment variable to a file descriptor
   // over which we can signal that we have completed our startup and can be
   // chrooted.
   const char* const sandbox_fd_string = getenv("SBX_D");
 
   if (sandbox_fd_string) {
     // Use the SUID sandbox.  This still allows the seccomp sandbox to
     // be enabled by the process later.
     g_suid_sandbox_active = true;
 
     char* endptr;
     const long fd_long = strtol(sandbox_fd_string, &endptr, 10);
     if (!*sandbox_fd_string || *endptr || fd_long < 0 || fd_long > INT_MAX)
       return false;
     const int fd = fd_long;
 
-    PreSandboxInit();
-
     static const char kMsgChrootMe = 'C';
     static const char kMsgChrootSuccessful = 'O';
 
     if (HANDLE_EINTR(write(fd, &kMsgChrootMe, 1)) != 1) {
       LOG(ERROR) << "Failed to write to chroot pipe: " << errno;
       return false;
     }
 
     // We need to reap the chroot helper process in any event:
     wait(NULL);
 
     char reply;
     if (HANDLE_EINTR(read(fd, &reply, 1)) != 1) {
       LOG(ERROR) << "Failed to read from chroot pipe: " << errno;
       return false;
     }
 
     if (reply != kMsgChrootSuccessful) {
       LOG(ERROR) << "Error code reply from chroot helper";
       return false;
     }
 
-    SkiaFontConfigSetImplementation(
-        new FontConfigIPC(kMagicSandboxIPCDescriptor));
-
 #if !defined(OS_OPENBSD)
     // Previously, we required that the binary be non-readable. This causes the
     // kernel to mark the process as non-dumpable at startup. The thinking was
     // that, although we were putting the renderers into a PID namespace (with
     // the SUID sandbox), they would nonetheless be in the /same/ PID
     // namespace. So they could ptrace each other unless they were non-dumpable.
     //
     // If the binary was readable, then there would be a window between process
     // startup and the point where we set the non-dumpable flag in which a
     // compromised renderer could ptrace attach.
     //
     // However, now that we have a zygote model, only the (trusted) zygote
     // exists at this point and we can set the non-dumpable flag which is
     // inherited by all our renderer children.
     //
     // Note: a non-dumpable process can't be debugged. To debug sandbox-related
     // issues, one can specify --allow-sandbox-debugging to let the process be
     // dumpable.
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
     if (!command_line.HasSwitch(switches::kAllowSandboxDebugging)) {
       prctl(PR_SET_DUMPABLE, 0, 0, 0, 0);
       if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {
         LOG(ERROR) << "Failed to set non-dumpable flag";
         return false;
       }
     }
 #endif
-#if defined(SECCOMP_SANDBOX)
-  } else if (SeccompSandboxEnabled()) {
-    PreSandboxInit();
-    SkiaFontConfigSetImplementation(
-        new FontConfigIPC(kMagicSandboxIPCDescriptor));
-#endif
-  } else {
-    SkiaFontConfigUseDirectImplementation();
   }
 
   return true;
 }
 #else  // CHROMIUM_SELINUX
 
 static bool EnterSandbox() {
   PreSandboxInit();
   SkiaFontConfigSetImplementation(
       new FontConfigIPC(kMagicSandboxIPCDescriptor));
@@ skipping 62 matching lines @@
       VLOG(1) << "Enabling experimental Seccomp sandbox.";
       sandbox_flags |= ZygoteHostImpl::kSandboxSeccomp;
     }
   }
 #endif  // SECCOMP_SANDBOX
 
   Zygote zygote(sandbox_flags, forkdelegate);
   // This function call can return multiple times, once per fork().
   return zygote.ProcessRequests();
 }