Move UnixDomainSocket to base namespace

content/browser/zygote_host/zygote_host_impl_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/zygote_host_impl_linux.h"
 
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ skipping 46 matching lines @@
 
 // Receive a fixed message on fd and return the sender's PID.
 // Returns true if the message received matches the expected message.
 bool ReceiveFixedMessage(int fd,
                          const char* expect_msg,
                          size_t expect_len,
                          base::ProcessId* sender_pid) {
   char buf[expect_len + 1];
   ScopedVector<base::ScopedFD> fds_vec;
 
-  const ssize_t len = UnixDomainSocket::RecvMsgWithPid(
+  const ssize_t len = base::UnixDomainSocket::RecvMsgWithPid(
       fd, buf, sizeof(buf), &fds_vec, sender_pid);
   if (static_cast<size_t>(len) != expect_len)
     return false;
   if (memcmp(buf, expect_msg, expect_len) != 0)
     return false;
   if (!fds_vec.empty())
     return false;
   return true;
 }
 
@@ skipping 29 matching lines @@
   init_ = true;
 
   base::FilePath chrome_path;
   CHECK(PathService::Get(base::FILE_EXE, &chrome_path));
   base::CommandLine cmd_line(chrome_path);
 
   cmd_line.AppendSwitchASCII(switches::kProcessType, switches::kZygoteProcess);
 
   int fds[2];
   CHECK(socketpair(AF_UNIX, SOCK_SEQPACKET, 0, fds) == 0);
-  CHECK(UnixDomainSocket::EnableReceiveProcessId(fds[0]));
+  CHECK(base::UnixDomainSocket::EnableReceiveProcessId(fds[0]));
   base::FileHandleMappingVector fds_to_map;
   fds_to_map.push_back(std::make_pair(fds[1], kZygoteSocketPairFd));
 
   base::LaunchOptions options;
   const base::CommandLine& browser_command_line =
       *base::CommandLine::ForCurrentProcess();
   if (browser_command_line.HasSwitch(switches::kZygoteCmdPrefix)) {
     cmd_line.PrependWrapper(
         browser_command_line.GetSwitchValueNative(switches::kZygoteCmdPrefix));
   }
@@ skipping 146 matching lines @@
     TearDown();
   }
 }
 
 bool ZygoteHostImpl::SendMessage(const Pickle& data,
                                  const std::vector<int>* fds) {
   DCHECK_NE(-1, control_fd_);
   CHECK(data.size() <= kZygoteMaxMessageLength)
       << "Trying to send too-large message to zygote (sending " << data.size()
       << " bytes, max is " << kZygoteMaxMessageLength << ")";
-  CHECK(!fds || fds->size() <= UnixDomainSocket::kMaxFileDescriptors)
+  CHECK(!fds || fds->size() <= base::UnixDomainSocket::kMaxFileDescriptors)
       << "Trying to send message with too many file descriptors to zygote "
       << "(sending " << fds->size() << ", max is "
-      << UnixDomainSocket::kMaxFileDescriptors << ")";
+      << base::UnixDomainSocket::kMaxFileDescriptors << ")";
 
-  return UnixDomainSocket::SendMsg(control_fd_,
-                                   data.data(), data.size(),
-                                   fds ? *fds : std::vector<int>());
+  return base::UnixDomainSocket::SendMsg(control_fd_,
+                                         data.data(), data.size(),
+                                         fds ? *fds : std::vector<int>());
 }
 
 ssize_t ZygoteHostImpl::ReadReply(void* buf, size_t buf_len) {
   DCHECK_NE(-1, control_fd_);
   // At startup we send a kZygoteCommandGetSandboxStatus request to the zygote,
   // but don't wait for the reply. Thus, the first time that we read from the
   // zygote, we get the reply to that request.
   if (!have_read_sandbox_status_word_) {
     if (HANDLE_EINTR(read(control_fd_, &sandbox_status_,
                           sizeof(sandbox_status_))) !=
@@ skipping 11 matching lines @@
 pid_t ZygoteHostImpl::ForkRequest(const std::vector<std::string>& argv,
                                   scoped_ptr<FileDescriptorInfo> mapping,
                                   const std::string& process_type) {
   DCHECK(init_);
   Pickle pickle;
 
   int raw_socks[2];
   PCHECK(0 == socketpair(AF_UNIX, SOCK_SEQPACKET, 0, raw_socks));
   base::ScopedFD my_sock(raw_socks[0]);
   base::ScopedFD peer_sock(raw_socks[1]);
-  CHECK(UnixDomainSocket::EnableReceiveProcessId(my_sock.get()));
+  CHECK(base::UnixDomainSocket::EnableReceiveProcessId(my_sock.get()));
 
   pickle.WriteInt(kZygoteCommandFork);
   pickle.WriteString(process_type);
   pickle.WriteInt(argv.size());
   for (std::vector<std::string>::const_iterator
        i = argv.begin(); i != argv.end(); ++i)
     pickle.WriteString(*i);
 
   // Fork requests contain one file descriptor for the PID oracle, and one
   // more for each file descriptor mapping for the child process.
@@ skipping 22 matching lines @@
     if (!SendMessage(pickle, &fds))
       return base::kNullProcessHandle;
     mapping.reset();
     peer_sock.reset();
 
     {
       char buf[sizeof(kZygoteChildPingMessage) + 1];
       ScopedVector<base::ScopedFD> recv_fds;
       base::ProcessId real_pid;
 
-      ssize_t n = UnixDomainSocket::RecvMsgWithPid(
+      ssize_t n = base::UnixDomainSocket::RecvMsgWithPid(
           my_sock.get(), buf, sizeof(buf), &recv_fds, &real_pid);
       if (n != sizeof(kZygoteChildPingMessage) ||
           0 != memcmp(buf,
                       kZygoteChildPingMessage,
                       sizeof(kZygoteChildPingMessage))) {
         // Zygote children should still be trustworthy when they're supposed to
         // ping us, so something's broken if we don't receive a valid ping.
         LOG(ERROR) << "Did not receive ping from zygote child";
         NOTREACHED();
         real_pid = -1;
@@ skipping 216 matching lines @@
   }
 
   if (!sandbox::Credentials::CanCreateProcessInNewUserNS()) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace content