Add ChannelPosix::ResetSafely() to deal with a lingering crash

ipc/ipc_channel_posix.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 "ipc/ipc_channel_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
@@ skipping 171 matching lines @@
 
 ChannelPosix::ChannelPosix(const IPC::ChannelHandle& channel_handle,
                            Mode mode, Listener* listener)
     : ChannelReader(listener),
       mode_(mode),
       peer_pid_(base::kNullProcessId),
       is_blocked_on_write_(false),
       waiting_connect_(true),
       message_send_bytes_written_(0),
       pipe_name_(channel_handle.name),
+      in_dtor_(false),
       must_unlink_(false) {
   memset(input_cmsg_buf_, 0, sizeof(input_cmsg_buf_));
   if (!CreatePipe(channel_handle)) {
     // The pipe may have been closed already.
     const char *modestr = (mode_ & MODE_SERVER_FLAG) ? "server" : "client";
     LOG(WARNING) << "Unable to create pipe named \"" << channel_handle.name
                  << "\" in " << modestr << " mode";
   }
 }
 
 ChannelPosix::~ChannelPosix() {
+  in_dtor_ = true;
   Close();
 }
 
 bool SocketPair(int* fd1, int* fd2) {
   int pipe_fds[2];
   if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds) != 0) {
     PLOG(ERROR) << "socketpair()";
     return false;
   }
 
@@ skipping 391 matching lines @@
 bool ChannelPosix::GetPeerEuid(uid_t* peer_euid) const {
   DCHECK(!(mode_ & MODE_SERVER) || HasAcceptedConnection());
   return IPC::GetPeerEuid(pipe_.get(), peer_euid);
 }
 #endif
 
 void ChannelPosix::ResetToAcceptingConnectionState() {
   // Unregister libevent for the unix domain socket and close it.
   read_watcher_.StopWatchingFileDescriptor();
   write_watcher_.StopWatchingFileDescriptor();
-  pipe_.reset();
+  ResetSafely(&pipe_);
 #if defined(IPC_USES_READWRITE)
   fd_pipe_.reset();
   remote_fd_pipe_.reset();
 #endif  // IPC_USES_READWRITE
 
   while (!output_queue_.empty()) {
     Message* m = output_queue_.front();
     output_queue_.pop();
     delete m;
   }
@@ skipping 446 matching lines @@
 }
 
 base::ProcessId ChannelPosix::GetPeerPID() const {
   return peer_pid_;
 }
 
 base::ProcessId ChannelPosix::GetSelfPID() const {
   return GetHelloMessageProcId();
 }
 
+void ChannelPosix::ResetSafely(base::ScopedFD* fd) {
+  if (!in_dtor_) {
+    fd->reset();
+    return;
+  }
+
+  // crbug.com/449233
+  // The CL [1] tightened the error check for closing FDs, but it turned
+  // out that there are existing cases that hit the newly added check.
+  // ResetSafely() is the workaround for that crash, turning it from
+  // from PCHECK() to DPCHECK() so that it doesn't crash in production.
+  // [1] https://crrev.com/ce44fef5fd60dd2be5c587d4b084bdcd36adcee4
+  int fd_to_close = fd->release();
+  if (-1 != fd_to_close) {
+    int rv = IGNORE_EINTR(close(fd_to_close));
+    DPCHECK(0 == rv);
+  }
+}
+
 //------------------------------------------------------------------------------
 // Channel's methods
 
 // static
 scoped_ptr<Channel> Channel::Create(
     const IPC::ChannelHandle &channel_handle, Mode mode, Listener* listener) {
   return make_scoped_ptr(new ChannelPosix(channel_handle, mode, listener));
 }
 
 // static
@@ skipping 15 matching lines @@
 }
 
 #if defined(OS_LINUX)
 // static
 void Channel::SetGlobalPid(int pid) {
   ChannelPosix::SetGlobalPid(pid);
 }
 #endif  // OS_LINUX
 
 }  // namespace IPC