Enable zygote manager by default.

base/zygote_manager.cc

 // Copyright (c) 2006-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 "base/zygote_manager.h"
 
 #if defined(OS_LINUX)
 
 #include <errno.h>
 #include <fcntl.h>
@@ skipping 36 matching lines @@
   }
   if (lockfd_ != -1) {
     close(lockfd_);
     lockfd_ = -1;
   }
   if (canary_fd_ != -1) {
     // Wake up the poll() in ReadAndHandleMessage()
     close(canary_fd_);
     canary_fd_ = -1;
   }
+#ifndef OFFICIAL_BUILD
+  // Closing the canary kills the server,
+  // so after this it's ok for e.g. unit tests
+  // to start a new zygote server.
+  (void) unsetenv("ZYGOTE_MANAGER_STARTED");
+#endif
 }
 
 // Runs in client process
 ZygoteManager* ZygoteManager::Get() {
   static bool checked = false;
   static bool enabled = false;
   if (!checked) {
-    enabled = (getenv("ENABLE_ZYGOTE_MANAGER") != NULL);
-    // sanity check - make sure all the places that relaunch chrome
-    // have been zygotified.
-    if (enabled)
-      DCHECK(getenv("ZYGOTE_MANAGER_STARTED") == NULL)
-          << "fork/exec used instead of LongFork";
-    (void) setenv("ZYGOTE_MANAGER_STARTED", "1", 1);
+    enabled = (getenv("DISABLE_ZYGOTE_MANAGER") == NULL);
     checked = true;
   }
   if (!enabled)
     return NULL;
   return Singleton<ZygoteManager>::get();
 }
 
 // Runs in zygote manager process
 int ZygoteManager::UnpickleHeader(const Pickle& reply, void** iter) {
   std::string magic;
@@ skipping 506 matching lines @@
   // Wait at most one minute.  This lets us detect case where
   // canary socket is closed abruptly because the main client aborted.
   // Also lets us reap dead children once a minute even if we don't get SIGCHLD.
   // We'd like to wait less time, but that's hard on battery life.
   // Note: handle EINTR manually here, not with wrapper, as we need
   // to return when we're interrupted so caller can reap promptly.
   int nactive = poll(watcher, 2, 60*1000);
 
   if (nactive == -1) {
     if (errno == EINTR) {
-      LOG(INFO) << "poll interrupted";
       // Probably SIGCHLD.  Return to main loop so it can reap.
       return true;
     }
     LOG(ERROR) << "poll failed, errno " << errno << ", aborting";
     return false;
   }
 
   // If it was the canary, exit
   if (watcher[0].revents != 0) {
     LOG(INFO) << "notified of peer destruction, exiting";
@@ skipping 108 matching lines @@
   return true;
 }
 
 // Called only by ChromeMain(), forks the zygote manager process.
 std::vector<std::string>* ZygoteManager::Start() {
   DCHECK(lockfd_ == -1);
   DCHECK(canary_fd_ == -1);
   DCHECK(server_fd_ == -1);
   DCHECK(client_fd_ == -1);
 
+#ifndef OFFICIAL_BUILD
+  // Disallow nested ZygoteManager servers
+  CHECK(getenv("ZYGOTE_MANAGER_STARTED") == NULL) << "already started?!";
+  (void) setenv("ZYGOTE_MANAGER_STARTED", "1", 1);
+#endif
+
   int pipe_fds[2];
 
   // Avoid using the reserved fd slots.
   int reserved_fds[kReservedFds];
   for (int i=0; i < kReservedFds; i++)
     reserved_fds[i] = open("/dev/null", O_RDONLY, 0);
 
   // Create the main communications pipe.
   int err = HANDLE_EINTR(socketpair(AF_UNIX, SOCK_DGRAM, 0, pipe_fds));
   if (err != 0) {
@@ skipping 18 matching lines @@
   lockfd_ = mkstemp(lockfile);
   if (lockfd_ == -1) {
     // TODO(dkegel): real error handling
     exit(99);
   }
   lockfile_.assign(lockfile);
 
   // Fork a fork server.
   pid_t childpid = fork();
 
-  if (childpid) {
+  if (!childpid) {
     for (int i=0; i < kReservedFds; i++)
       close(reserved_fds[i]);
 
-    // Original parent.  Continues on with the main program
+    // Original child.  Continues on with the main program
     // and becomes the first client.
     close(server_fd_);
     server_fd_ = -1;
 
     close(pipe_fds[1]);
     canary_fd_ = pipe_fds[0];
 
     // Return now to indicate this is the original process.
     return NULL;
   } else {
     close(lockfd_);
 
     close(pipe_fds[0]);
     canary_fd_ = pipe_fds[1];
 
     // We need to accept SIGCHLD, even though our handler is a no-op because
     // otherwise we cannot wait on children. (According to POSIX 2001.)
     // (And otherwise poll() might not wake up on SIGCHLD.)
     struct sigaction action;
     memset(&action, 0, sizeof(action));
     action.sa_handler = SIGCHLDHandler;
     CHECK(sigaction(SIGCHLD, &action, NULL) == 0);
 
-    // Original child.  Acts as the server.
+    // Original process.  Acts as the server.
     while (true) {
       std::vector<std::string>* newargv = NULL;
       if (!ReadAndHandleMessage(&newargv))
         break;
       if (newargv) {
         // Return new commandline to show caller this is a new child process.
         return newargv;
       }
       // Server process continues around loop.
 
       // Reap children.
       while (true) {
         int status = -1;
         pid_t reaped = waitpid(-1, &status, WNOHANG);
         if (reaped != -1 && reaped != 0) {
           LOG(INFO) << "Reaped pid " << reaped;
           continue;
         }
         break;
       }
     }
     // Server cleanup after EOF or error reading from the socket.
-    // Chrome doesn't seem to get here in practice.
     Delete(FilePath(lockfile_), false);
     // TODO(dkegel): real error handling
     LOG(INFO) << "exiting.  " << cached_fds_.size() << " cached fds.";
     std::map<std::string, int>::iterator i;
     for (i = cached_fds_.begin(); i != cached_fds_.end(); ++i) {
       LOG(INFO) << "Closing fd " << i->second << " filename " << i->first;
       close(i->second);
     }
-    exit(-1);
+    exit(0);
   }
 }
 }
 #endif  // defined(OS_LINUX)