Make SandboxIPCProcess a thread.

content/browser/renderer_host/sandbox_ipc_linux.cc

Index: content/browser/renderer_host/sandbox_ipc_linux.cc
diff --git a/content/browser/renderer_host/sandbox_ipc_linux.cc b/content/browser/renderer_host/sandbox_ipc_linux.cc
index ad1747e01736ec41d009c825a9562f8b3b8708d0..5a17646e9aae4fd1669872f1c711cc97c60fdd14 100644
--- a/content/browser/renderer_host/sandbox_ipc_linux.cc
+++ b/content/browser/renderer_host/sandbox_ipc_linux.cc
@@ -127,10 +127,9 @@ static void MSCharSetToFontconfig(FcLangSet* langset, unsigned fdwCharSet) {
 
 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);
@@ -140,33 +139,23 @@ SandboxIPCProcess::SandboxIPCProcess(int lifeline_fd,
   // 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 */));
+    const int r =
+        HANDLE_EINTR(poll(pfds, arraysize(pfds), -1 /* no timeout */));
     // '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;
       }
       continue;
@@ -174,18 +163,20 @@ void SandboxIPCProcess::Run() {
 
     failed_polls = 0;
 
-    if (pfds[0].revents) {
-      // our parent died so we should too.
-      _exit(0);
+    // If poll(2) reports an error condition in the fd,
+    // we assume the zygote is gone and we return.
+    if (pfds[0].revents & POLLERR) {
+      LOG(ERROR) << "poll: Error condition in one or more fds.";

[piman, 2014/04/29 21:23:51]

Why LOG? This is the normal exit path.

[Jorge Lucangeli Obes, 2014/04/29 21:40:15]

Mostly to make sure that if something is happening that causes POLLERR *before*
the browser exits, we had a way to know. I can turn it into a VLOG.

[Jorge Lucangeli Obes, 2014/04/30 17:58:20]

Done.

+      return;
     }
 
-    if (pfds[1].revents) {
+    if (pfds[0].revents & POLLIN) {
       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
@@ -234,7 +225,7 @@ error:
   }
 }
 
-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])
@@ -244,7 +235,7 @@ int SandboxIPCProcess::FindOrAddPath(const SkString& path) {
   return count;
 }
 
-void SandboxIPCProcess::HandleFontMatchRequest(int fd,
+void SandboxIPCHandler::HandleFontMatchRequest(int fd,
                                                const Pickle& pickle,
                                                PickleIterator iter,
                                                std::vector<int>& fds) {
@@ -283,7 +274,7 @@ void SandboxIPCProcess::HandleFontMatchRequest(int fd,
   SendRendererReply(fds, reply, -1);
 }
 
-void SandboxIPCProcess::HandleFontOpenRequest(int fd,
+void SandboxIPCHandler::HandleFontOpenRequest(int fd,
                                               const Pickle& pickle,
                                               PickleIterator iter,
                                               std::vector<int>& fds) {
@@ -311,12 +302,12 @@ void SandboxIPCProcess::HandleFontOpenRequest(int fd,
   }
 }
 
-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;
@@ -341,7 +332,7 @@ void SandboxIPCProcess::HandleGetFontFamilyForChar(int fd,
   SendRendererReply(fds, reply, -1);
 }
 
-void SandboxIPCProcess::HandleGetStyleForStrike(int fd,
+void SandboxIPCHandler::HandleGetStyleForStrike(int fd,
                                                 const Pickle& pickle,
                                                 PickleIterator iter,
                                                 std::vector<int>& fds) {
@@ -369,7 +360,7 @@ void SandboxIPCProcess::HandleGetStyleForStrike(int fd,
   SendRendererReply(fds, reply, -1);
 }
 
-void SandboxIPCProcess::HandleLocaltime(int fd,
+void SandboxIPCHandler::HandleLocaltime(int fd,
                                         const Pickle& pickle,
                                         PickleIterator iter,
                                         std::vector<int>& fds) {
@@ -401,7 +392,7 @@ void SandboxIPCProcess::HandleLocaltime(int fd,
   SendRendererReply(fds, reply, -1);
 }
 
-void SandboxIPCProcess::HandleGetChildWithInode(int fd,
+void SandboxIPCHandler::HandleGetChildWithInode(int fd,
                                                 const Pickle& pickle,
                                                 PickleIterator iter,
                                                 std::vector<int>& fds) {
@@ -435,7 +426,7 @@ void SandboxIPCProcess::HandleGetChildWithInode(int fd,
   SendRendererReply(fds, reply, -1);
 }
 
-void SandboxIPCProcess::HandleMakeSharedMemorySegment(int fd,
+void SandboxIPCHandler::HandleMakeSharedMemorySegment(int fd,
                                                       const Pickle& pickle,
                                                       PickleIterator iter,
                                                       std::vector<int>& fds) {
@@ -454,7 +445,7 @@ void SandboxIPCProcess::HandleMakeSharedMemorySegment(int fd,
   SendRendererReply(fds, reply, shm_fd);
 }
 
-void SandboxIPCProcess::HandleMatchWithFallback(int fd,
+void SandboxIPCHandler::HandleMatchWithFallback(int fd,
                                                 const Pickle& pickle,
                                                 PickleIterator iter,
                                                 std::vector<int>& fds) {
@@ -613,7 +604,7 @@ void SandboxIPCProcess::HandleMatchWithFallback(int fd,
   }
 }
 
-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;
@@ -648,13 +639,13 @@ void SandboxIPCProcess::SendRendererReply(const std::vector<int>& fds,
     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);