Define magic descriptors in one place.

content/zygote/zygote_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/zygote/zygote_linux.h"
 
 #include <fcntl.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/linux_util.h"
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/global_descriptors.h"
 #include "base/posix/unix_domain_socket_linux.h"
 #include "base/process/kill.h"
+#include "content/common/child_process_sandbox_support_impl_linux.h"
 #include "content/common/sandbox_linux.h"
 #include "content/common/set_process_title.h"
 #include "content/common/zygote_commands_linux.h"
 #include "content/public/common/content_descriptors.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/sandbox_linux.h"
 #include "content/public/common/zygote_fork_delegate_linux.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_switches.h"
 
 // See http://code.google.com/p/chromium/wiki/LinuxZygote
 
 namespace content {
 
 namespace {
 
 // NOP function. See below where this handler is installed.
 void SIGCHLDHandler(int signal) {
 }
 
 }  // namespace
 
-const int Zygote::kMagicSandboxIPCDescriptor;
-
 Zygote::Zygote(int sandbox_flags,
                ZygoteForkDelegate* helper)
     : sandbox_flags_(sandbox_flags),
       helper_(helper),
       initial_uma_sample_(0),
       initial_uma_boundary_value_(0) {
   if (helper_) {
     helper_->InitialUMA(&initial_uma_name_,
                         &initial_uma_sample_,
                         &initial_uma_boundary_value_);
@@ skipping 13 matching lines @@
   // otherwise we cannot wait on children. (According to POSIX 2001.)
   struct sigaction action;
   memset(&action, 0, sizeof(action));
   action.sa_handler = &SIGCHLDHandler;
   CHECK(sigaction(SIGCHLD, &action, NULL) == 0);
 
   if (UsingSUIDSandbox()) {
     // Let the ZygoteHost know we are ready to go.
     // The receiving code is in content/browser/zygote_host_linux.cc.
     std::vector<int> empty;
-    bool r = UnixDomainSocket::SendMsg(kBrowserDescriptor,
+    bool r = UnixDomainSocket::SendMsg(kZygoteSocketPairFd,
                                        kZygoteHelloMessage,
                                        sizeof(kZygoteHelloMessage), empty);
 #if defined(OS_CHROMEOS)
     LOG_IF(WARNING, !r) << "Sending zygote magic failed";
     // Exit normally on chromeos because session manager may send SIGTERM
     // right after the process starts and it may fail to send zygote magic
     // number to browser process.
     if (!r)
       _exit(RESULT_CODE_NORMAL_EXIT);
 #else
     CHECK(r) << "Sending zygote magic failed";
 #endif
   }
 
   for (;;) {
     // This function call can return multiple times, once per fork().
-    if (HandleRequestFromBrowser(kBrowserDescriptor))
+    if (HandleRequestFromBrowser(kZygoteSocketPairFd))
       return true;
   }
 }
 
 bool Zygote::GetProcessInfo(base::ProcessHandle pid,
                             ZygoteProcessInfo* process_info) {
   DCHECK(process_info);
   const ZygoteProcessMap::const_iterator it = process_info_map_.find(pid);
   if (it == process_info_map_.end()) {
     return false;
@@ skipping 248 matching lines @@
     close(pipe_fds[0]);
     pipe_fds[0] = -1;
     base::ProcessId real_pid;
     if (UsingSUIDSandbox()) {
       uint8_t reply_buf[512];
       Pickle request;
       request.WriteInt(LinuxSandbox::METHOD_GET_CHILD_WITH_INODE);
       request.WriteUInt64(dummy_inode);
 
       const ssize_t r = UnixDomainSocket::SendRecvMsg(
-          kMagicSandboxIPCDescriptor, reply_buf, sizeof(reply_buf), NULL,
+          GetSandboxFD(), reply_buf, sizeof(reply_buf), NULL,
           request);
       if (r == -1) {
         LOG(ERROR) << "Failed to get child process's real PID";
         goto error;
       }
 
       Pickle reply(reinterpret_cast<char*>(reply_buf), r);
       PickleIterator iter(reply);
       if (!reply.ReadInt(&iter, &real_pid))
         goto error;
@@ skipping 82 matching lines @@
     return -1;
 
   for (int i = 0; i < numfds; ++i) {
     base::GlobalDescriptors::Key key;
     if (!pickle.ReadUInt32(&iter, &key))
       return -1;
     mapping.push_back(std::make_pair(key, fds[i]));
   }
 
   mapping.push_back(std::make_pair(
-      static_cast<uint32_t>(kSandboxIPCChannel), kMagicSandboxIPCDescriptor));
+      static_cast<uint32_t>(kSandboxIPCChannel), GetSandboxFD()));
 
   // Returns twice, once per process.
   base::ProcessId child_pid = ForkWithRealPid(process_type, fds, channel_id,
                                               uma_name, uma_sample,
                                               uma_boundary_value);
   if (!child_pid) {
     // This is the child process.
 
-    close(kBrowserDescriptor);  // Our socket from the browser.
+    close(kZygoteSocketPairFd);  // Our socket from the browser.
     if (UsingSUIDSandbox())
       close(kZygoteIdFd);  // Another socket from the browser.
     base::GlobalDescriptors::GetInstance()->Reset(mapping);
 
     // Reset the process-wide command line to our new command line.
     CommandLine::Reset();
     CommandLine::Init(0, NULL);
     CommandLine::ForCurrentProcess()->InitFromArgv(args);
 
     // Update the process title. The argv was already cached by the call to
@@ skipping 50 matching lines @@
                                     PickleIterator iter) {
   if (HANDLE_EINTR(write(fd, &sandbox_flags_, sizeof(sandbox_flags_))) !=
                    sizeof(sandbox_flags_)) {
     PLOG(ERROR) << "write";
   }
 
   return false;
 }
 
 }  // namespace content