Make SandboxIPCProcess a thread.

content/browser/renderer_host/sandbox_ipc_linux.cc

 // Copyright 2014 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/renderer_host/sandbox_ipc_linux.h"
 
 #include <fcntl.h>
 #include <fontconfig/fontconfig.h>
 #include <sys/poll.h>
 #include <sys/socket.h>
@@ skipping 109 matching lines @@
       // default:
       // Don't add any languages in that case that we don't recognise the
       // constant.
   }
 }
 
 }  // namespace
 
 namespace content {
 
-SandboxIPCProcess::SandboxIPCProcess(int lifeline_fd,
-                                     int browser_socket,
+SandboxIPCHandler::SandboxIPCHandler(int browser_socket,
                                      std::string sandbox_cmd)
-    : lifeline_fd_(lifeline_fd), browser_socket_(browser_socket) {
+    : browser_socket_(browser_socket) {
   if (!sandbox_cmd.empty()) {
     sandbox_cmd_.push_back(sandbox_cmd);
     sandbox_cmd_.push_back(base::kFindInodeSwitch);
   }
 
   // FontConfig doesn't provide a standard property to control subpixel
   // positioning, so we pass the current setting through to WebKit.
   WebFontInfo::setSubpixelPositioning(
       gfx::GetDefaultWebkitSubpixelPositioning());
-
-  CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  command_line.AppendSwitchASCII(switches::kProcessType,
-                                 switches::kSandboxIPCProcess);
-
-  // Update the process title. The argv was already cached by the call to
-  // SetProcessTitleFromCommandLine in content_main_runner.cc, so we can pass
-  // NULL here (we don't have the original argv at this point).
-  SetProcessTitleFromCommandLine(NULL);
 }
 
-void SandboxIPCProcess::Run() {
-  struct pollfd pfds[2];
-  pfds[0].fd = lifeline_fd_;
+void SandboxIPCHandler::Run() {
+  struct pollfd pfds[1];
+  pfds[0].fd = browser_socket_;
   pfds[0].events = POLLIN;
-  pfds[1].fd = browser_socket_;
-  pfds[1].events = POLLIN;
 
   int failed_polls = 0;
   for (;;) {
     const int r = HANDLE_EINTR(poll(pfds, 2, -1 /* no timeout */));

[piman, 2014/04/29 01:47:02]

Actually, we should only poll 1 fd, not 2.

[jln (very slow on Chromium), 2014/04/29 19:45:28]

s/2/arraysize(pfds)/

[Jorge Lucangeli Obes, 2014/04/29 20:51:10]

Done.

     // '0' is not a possible return value with no timeout.
     DCHECK_NE(0, r);
     if (r < 0) {
       PLOG(WARNING) << "poll";
       if (failed_polls++ == 3) {
-        LOG(FATAL) << "poll(2) failing. RenderSandboxHostLinux aborting.";
+        LOG(FATAL) << "poll(2) failing. SandboxIPCHandler aborting.";
         return;

[piman, 2014/04/29 00:25:46]

How do we ever exit the thread?

[Jorge Lucangeli Obes, 2014/04/29 20:51:10]

Done.

       }
       continue;
     }
 
     failed_polls = 0;
 
     if (pfds[0].revents) {
-      // our parent died so we should too.
-      _exit(0);
-    }
-
-    if (pfds[1].revents) {
       HandleRequestFromRenderer(browser_socket_);
     }
   }
 }
 
-void SandboxIPCProcess::HandleRequestFromRenderer(int fd) {
+void SandboxIPCHandler::HandleRequestFromRenderer(int fd) {
   std::vector<int> fds;
 
   // A FontConfigIPC::METHOD_MATCH message could be kMaxFontFamilyLength
   // bytes long (this is the largest message type).
   // 128 bytes padding are necessary so recvmsg() does not return MSG_TRUNC
   // error for a maximum length message.
   char buf[FontConfigIPC::kMaxFontFamilyLength + 128];
 
   const ssize_t len = UnixDomainSocket::RecvMsg(fd, buf, sizeof(buf), &fds);
   if (len == -1) {
@@ skipping 28 matching lines @@
   } else if (kind == LinuxSandbox::METHOD_MATCH_WITH_FALLBACK) {
     HandleMatchWithFallback(fd, pickle, iter, fds);
   }
 
 error:
   for (std::vector<int>::const_iterator i = fds.begin(); i != fds.end(); ++i) {
     close(*i);
   }
 }
 
-int SandboxIPCProcess::FindOrAddPath(const SkString& path) {
+int SandboxIPCHandler::FindOrAddPath(const SkString& path) {
   int count = paths_.count();
   for (int i = 0; i < count; ++i) {
     if (path == *paths_[i])
       return i;
   }
   *paths_.append() = new SkString(path);
   return count;
 }
 
-void SandboxIPCProcess::HandleFontMatchRequest(int fd,
+void SandboxIPCHandler::HandleFontMatchRequest(int fd,
                                                const Pickle& pickle,
                                                PickleIterator iter,
                                                std::vector<int>& fds) {
   uint32_t requested_style;
   std::string family;
   if (!pickle.ReadString(&iter, &family) ||
       !pickle.ReadUInt32(&iter, &requested_style))
     return;
 
   SkFontConfigInterface::FontIdentity result_identity;
@@ skipping 18 matching lines @@
     result_identity.fID = static_cast<uint32_t>(index);
 
     reply.WriteBool(true);
     skia::WriteSkString(&reply, result_family);
     skia::WriteSkFontIdentity(&reply, result_identity);
     reply.WriteUInt32(result_style);
   }
   SendRendererReply(fds, reply, -1);
 }
 
-void SandboxIPCProcess::HandleFontOpenRequest(int fd,
+void SandboxIPCHandler::HandleFontOpenRequest(int fd,
                                               const Pickle& pickle,
                                               PickleIterator iter,
                                               std::vector<int>& fds) {
   uint32_t index;
   if (!pickle.ReadUInt32(&iter, &index))
     return;
   if (index >= static_cast<uint32_t>(paths_.count()))
     return;
   const int result_fd = open(paths_[index]->c_str(), O_RDONLY);
 
   Pickle reply;
   if (result_fd == -1) {
     reply.WriteBool(false);
   } else {
     reply.WriteBool(true);
   }
 
   // The receiver will have its own access to the file, so we will close it
   // after this send.
   SendRendererReply(fds, reply, result_fd);
 
   if (result_fd >= 0) {
     int err = IGNORE_EINTR(close(result_fd));
     DCHECK(!err);
   }
 }
 
-void SandboxIPCProcess::HandleGetFontFamilyForChar(int fd,
+void SandboxIPCHandler::HandleGetFontFamilyForChar(int fd,
                                                    const Pickle& pickle,
                                                    PickleIterator iter,
                                                    std::vector<int>& fds) {
   // The other side of this call is
-  // chrome/renderer/renderer_sandbox_support_linux.cc
+  // content/common/child_process_sandbox_support_impl_linux.cc
 
   EnsureWebKitInitialized();
   WebUChar32 c;
   if (!pickle.ReadInt(&iter, &c))
     return;
 
   std::string preferred_locale;
   if (!pickle.ReadString(&iter, &preferred_locale))
     return;
 
   blink::WebFontFamily family;
   WebFontInfo::familyForChar(c, preferred_locale.c_str(), &family);
 
   Pickle reply;
   if (family.name.data()) {
     reply.WriteString(family.name.data());
   } else {
     reply.WriteString(std::string());
   }
   reply.WriteBool(family.isBold);
   reply.WriteBool(family.isItalic);
   SendRendererReply(fds, reply, -1);
 }
 
-void SandboxIPCProcess::HandleGetStyleForStrike(int fd,
+void SandboxIPCHandler::HandleGetStyleForStrike(int fd,
                                                 const Pickle& pickle,
                                                 PickleIterator iter,
                                                 std::vector<int>& fds) {
   std::string family;
   int sizeAndStyle;
 
   if (!pickle.ReadString(&iter, &family) ||
       !pickle.ReadInt(&iter, &sizeAndStyle)) {
     return;
   }
 
   EnsureWebKitInitialized();
   blink::WebFontRenderStyle style;
   WebFontInfo::renderStyleForStrike(family.c_str(), sizeAndStyle, &style);
 
   Pickle reply;
   reply.WriteInt(style.useBitmaps);
   reply.WriteInt(style.useAutoHint);
   reply.WriteInt(style.useHinting);
   reply.WriteInt(style.hintStyle);
   reply.WriteInt(style.useAntiAlias);
   reply.WriteInt(style.useSubpixelRendering);
   reply.WriteInt(style.useSubpixelPositioning);
 
   SendRendererReply(fds, reply, -1);
 }
 
-void SandboxIPCProcess::HandleLocaltime(int fd,
+void SandboxIPCHandler::HandleLocaltime(int fd,
                                         const Pickle& pickle,
                                         PickleIterator iter,
                                         std::vector<int>& fds) {
   // The other side of this call is in zygote_main_linux.cc
 
   std::string time_string;
   if (!pickle.ReadString(&iter, &time_string) ||
       time_string.size() != sizeof(time_t)) {
     return;
   }
@@ skipping 11 matching lines @@
                                 sizeof(struct tm));
     time_zone_string = expanded_time->tm_zone;
   }
 
   Pickle reply;
   reply.WriteString(result_string);
   reply.WriteString(time_zone_string);
   SendRendererReply(fds, reply, -1);
 }
 
-void SandboxIPCProcess::HandleGetChildWithInode(int fd,
+void SandboxIPCHandler::HandleGetChildWithInode(int fd,
                                                 const Pickle& pickle,
                                                 PickleIterator iter,
                                                 std::vector<int>& fds) {
   // The other side of this call is in zygote_main_linux.cc
   if (sandbox_cmd_.empty()) {
     LOG(ERROR) << "Not in the sandbox, this should not be called";
     return;
   }
 
   uint64_t inode;
@@ skipping 13 matching lines @@
     // Even though the pid is invalid, we still need to reply to the zygote
     // and not just return here.
     LOG(ERROR) << "Could not get pid";
   }
 
   Pickle reply;
   reply.WriteInt(pid);
   SendRendererReply(fds, reply, -1);
 }
 
-void SandboxIPCProcess::HandleMakeSharedMemorySegment(int fd,
+void SandboxIPCHandler::HandleMakeSharedMemorySegment(int fd,
                                                       const Pickle& pickle,
                                                       PickleIterator iter,
                                                       std::vector<int>& fds) {
   base::SharedMemoryCreateOptions options;
   uint32_t size;
   if (!pickle.ReadUInt32(&iter, &size))
     return;
   options.size = size;
   if (!pickle.ReadBool(&iter, &options.executable))
     return;
   int shm_fd = -1;
   base::SharedMemory shm;
   if (shm.Create(options))
     shm_fd = shm.handle().fd;
   Pickle reply;
   SendRendererReply(fds, reply, shm_fd);
 }
 
-void SandboxIPCProcess::HandleMatchWithFallback(int fd,
+void SandboxIPCHandler::HandleMatchWithFallback(int fd,
                                                 const Pickle& pickle,
                                                 PickleIterator iter,
                                                 std::vector<int>& fds) {
   // Unlike the other calls, for which we are an indirection in front of
   // WebKit or Skia, this call is always made via this sandbox helper
   // process. Therefore the fontconfig code goes in here directly.
 
   std::string face;
   bool is_bold, is_italic;
   uint32 charset, fallback_family;
@@ skipping 138 matching lines @@
 
   Pickle reply;
   SendRendererReply(fds, reply, font_fd);
 
   if (font_fd >= 0) {
     if (IGNORE_EINTR(close(font_fd)) < 0)
       PLOG(ERROR) << "close";
   }
 }
 
-void SandboxIPCProcess::SendRendererReply(const std::vector<int>& fds,
+void SandboxIPCHandler::SendRendererReply(const std::vector<int>& fds,
                                           const Pickle& reply,
                                           int reply_fd) {
   struct msghdr msg;
   memset(&msg, 0, sizeof(msg));
   struct iovec iov = {const_cast<void*>(reply.data()), reply.size()};
   msg.msg_iov = &iov;
   msg.msg_iovlen = 1;
 
   char control_buffer[CMSG_SPACE(sizeof(int))];
 
@@ skipping 14 matching lines @@
     cmsg->cmsg_type = SCM_RIGHTS;
     cmsg->cmsg_len = CMSG_LEN(sizeof(int));
     memcpy(CMSG_DATA(cmsg), &reply_fd, sizeof(reply_fd));
     msg.msg_controllen = cmsg->cmsg_len;
   }
 
   if (HANDLE_EINTR(sendmsg(fds[0], &msg, MSG_DONTWAIT)) < 0)
     PLOG(ERROR) << "sendmsg";
 }
 
-SandboxIPCProcess::~SandboxIPCProcess() {
+SandboxIPCHandler::~SandboxIPCHandler() {
   paths_.deleteAll();
   if (webkit_platform_support_)
     blink::shutdownWithoutV8();
 }
 
-void SandboxIPCProcess::EnsureWebKitInitialized() {
+void SandboxIPCHandler::EnsureWebKitInitialized() {
   if (webkit_platform_support_)
     return;
   webkit_platform_support_.reset(new BlinkPlatformImpl);
   blink::initializeWithoutV8(webkit_platform_support_.get());
 }
 
 }  // namespace content