This patch caused Chrome to be unable to load any web pages on Chrome OS.

ipc/ipc_channel_posix.cc

 // Copyright (c) 2011 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/types.h>
@@ skipping 291 matching lines @@
       message_send_bytes_written_(0),
       server_listen_pipe_(-1),
       pipe_(-1),
       client_pipe_(-1),
 #if defined(IPC_USES_READWRITE)
       fd_pipe_(-1),
       remote_fd_pipe_(-1),
 #endif  // IPC_USES_READWRITE
       pipe_name_(channel_handle.name),
       listener_(listener),
-      must_unlink_(false),
-      needs_override_peer_pid_(false),
-      override_peer_pid_(0) {
+      must_unlink_(false) {
   memset(input_buf_, 0, sizeof(input_buf_));
   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";
     // The pipe may have been closed already.
     LOG(WARNING) << "Unable to create pipe named \"" << channel_handle.name
                  << "\" in " << modestr << " mode";
   }
 }
@@ skipping 397 matching lines @@
             // subsequent file descriptor passing.
             DCHECK_EQ(m.file_descriptor_set()->size(), 1U);
             base::FileDescriptor descriptor;
             if (!m.ReadFileDescriptor(&iter, &descriptor)) {
               NOTREACHED();
             }
             fd_pipe_ = descriptor.fd;
             CHECK(descriptor.auto_close);
           }
 #endif  // IPC_USES_READWRITE
-          if (needs_override_peer_pid_) {
-            // If we already have the peer PID, use it.  Otherwise we'll call
-            // OnChannelConnected() in OverridePeerPid() below.
-            if (override_peer_pid_ != 0)
-              listener_->OnChannelConnected(override_peer_pid_);
-          } else {
-            listener_->OnChannelConnected(pid);
-          }
+          listener_->OnChannelConnected(pid);
         } else {
           listener_->OnMessageReceived(m);
         }
         p = message_tail;
       } else {
         // Last message is partial.
         break;
       }
       input_overflow_fds_ = std::vector<int>(&fds[fds_i], &fds[num_fds]);
       fds_i = 0;
@@ skipping 245 matching lines @@
 
   // Close any outstanding, received file descriptors.
   for (std::vector<int>::iterator
        i = input_overflow_fds_.begin(); i != input_overflow_fds_.end(); ++i) {
     if (HANDLE_EINTR(close(*i)) < 0)
       PLOG(ERROR) << "close";
   }
   input_overflow_fds_.clear();
 }
 
-#if defined(OS_LINUX)
-void Channel::ChannelImpl::SetNeedsOverridePeerPid() {
-  needs_override_peer_pid_ = true;
-}
-
-void Channel::ChannelImpl::OverridePeerPid(int32 peer_pid) {
-  DCHECK(needs_override_peer_pid_);
-  override_peer_pid_ = peer_pid;
-
-  // The browser learns the global PID of the renderers on the UI thread, and
-  // must post the data to the IO thread for us to use it here.  Therefore
-  // there is a race between the IPC channel processing the hello message
-  // and this function being called.  If fd_pipe_ != -1 then we've already
-  // received the hello message and we skipped OnChannelConnected() above,
-  // so call it here.
-  if (fd_pipe_ != -1) {
-    listener_->OnChannelConnected(peer_pid);
-  }
-}
-#endif  // defined(OS_LINUX)
-
 // static
 bool Channel::ChannelImpl::IsNamedServerInitialized(
     const std::string& channel_id) {
   return file_util::PathExists(FilePath(channel_id));
 }
 
 // Called by libevent when we can read from the pipe without blocking.
 void Channel::ChannelImpl::OnFileCanReadWithoutBlocking(int fd) {
   bool send_server_hello_msg = false;
   if (fd == server_listen_pipe_) {
@@ skipping 195 matching lines @@
 }
 
 bool Channel::GetClientEuid(uid_t* client_euid) const {
   return channel_impl_->GetClientEuid(client_euid);
 }
 
 void Channel::ResetToAcceptingConnectionState() {
   channel_impl_->ResetToAcceptingConnectionState();
 }
 
-#if defined(OS_LINUX)
-void Channel::SetNeedsOverridePeerPid() {
-  channel_impl_->SetNeedsOverridePeerPid();
-}
-
-void Channel::OverridePeerPid(int32 peer_pid) {
-  channel_impl_->OverridePeerPid(peer_pid);
-}
-#endif  // defined(OS_LINUX)
-
 // static
 bool Channel::IsNamedServerInitialized(const std::string& channel_id) {
   return ChannelImpl::IsNamedServerInitialized(channel_id);
 }
 
 }  // namespace IPC