Continue with the FreeBSD port - this version builds and links, though...

chrome/browser/zygote_main_linux.cc

 // Copyright (c) 2009 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 "build/build_config.h"
+
 #include <dlfcn.h>
 #include <unistd.h>
+#if defined(OS_FREEBSD)
+#include <signal.h>
+#else
 #include <sys/epoll.h>
+#endif
 #include <sys/types.h>
 #include <sys/socket.h>
+#if !defined(OS_FREEBSD)
 #include <sys/signal.h>
 #include <sys/prctl.h>
+#endif
 #include <sys/wait.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/global_descriptors_posix.h"
 #include "base/path_service.h"
 #include "base/pickle.h"
 #include "base/rand_util.h"
 #include "base/sys_info.h"
@@ skipping 378 matching lines @@
       return false;
     }
 
     if (reply != kChrootMeSuccess) {
       LOG(ERROR) << "Error code reply from chroot helper";
       return false;
     }
 
     SkiaFontConfigUseIPCImplementation(kMagicSandboxIPCDescriptor);
 
+    // TODO(benl): Do something for FreeBSD...
+#if !defined(OS_FREEBSD)
     // 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
   } else {
     SkiaFontConfigUseDirectImplementation();
   }
 
   return true;
 }
 
 bool ZygoteMain(const MainFunctionParams& params) {
   g_am_zygote_or_renderer = true;
 
   if (!MaybeEnterChroot()) {
     LOG(FATAL) << "Failed to enter sandbox. Fail safe abort. (errno: "
                << errno << ")";
     return false;
   }
 
   Zygote zygote;
   return zygote.ProcessRequests();
 }