multiple files: Move from DCHECK to DCHECK_EQ

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 98 matching lines @@
       if (HANDLE_EINTR(close(i->second)) < 0)
         PLOG(ERROR) << "close " << channel_id;
       map_.erase(i);
     }
   }
 
   // Insert a mapping from @channel_id to @fd. It's a fatal error to insert a
   // mapping if one already exists for the given channel_id
   void Insert(const std::string& channel_id, int fd) {
     base::AutoLock locked(lock_);
-    DCHECK(fd != -1);
+    DCHECK_NE(-1, fd);
 
     ChannelToFDMap::const_iterator i = map_.find(channel_id);
     CHECK(i == map_.end()) << "Creating second IPC server (fd " << fd << ") "
                            << "for '" << channel_id << "' while first "
                            << "(fd " << i->second << ") still exists";
     map_[channel_id] = fd;
   }
 
  private:
   base::Lock lock_;
@@ skipping 419 matching lines @@
     //     printf("Bug found!\n");
     // }
     if (msg.msg_controllen > 0) {
       // On OSX, CMSG_FIRSTHDR doesn't handle the case where controllen is 0
       // and will return a pointer into nowhere.
       for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg); cmsg;
            cmsg = CMSG_NXTHDR(&msg, cmsg)) {
         if (cmsg->cmsg_level == SOL_SOCKET &&
             cmsg->cmsg_type == SCM_RIGHTS) {
           const unsigned payload_len = cmsg->cmsg_len - CMSG_LEN(0);
-          DCHECK(payload_len % sizeof(int) == 0);
+          DCHECK_EQ(0U, payload_len % sizeof(int));
           wire_fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
           num_wire_fds = payload_len / 4;
 
           if (msg.msg_flags & MSG_CTRUNC) {
             LOG(ERROR) << "SCM_RIGHTS message was truncated"
                        << " cmsg_len:" << cmsg->cmsg_len
                        << " fd:" << pipe_;
             for (unsigned i = 0; i < num_wire_fds; ++i)
               if (HANDLE_EINTR(close(wire_fds[i])) < 0)
                 PLOG(ERROR) << "close " << i;
@@ skipping 59 matching lines @@
             struct iovec fd_pipe_iov = { &dummy, 1 };
             msg.msg_iov = &fd_pipe_iov;
             msg.msg_controllen = sizeof(input_cmsg_buf_);
             ssize_t n = HANDLE_EINTR(recvmsg(fd_pipe_, &msg, MSG_DONTWAIT));
             if (n == 1 && msg.msg_controllen > 0) {
               for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg); cmsg;
                    cmsg = CMSG_NXTHDR(&msg, cmsg)) {
                 if (cmsg->cmsg_level == SOL_SOCKET &&
                     cmsg->cmsg_type == SCM_RIGHTS) {
                   const unsigned payload_len = cmsg->cmsg_len - CMSG_LEN(0);
-                  DCHECK(payload_len % sizeof(int) == 0);
+                  DCHECK_EQ(0U, payload_len % sizeof(int));
                   wire_fds = reinterpret_cast<int*>(CMSG_DATA(cmsg));
                   num_wire_fds = payload_len / 4;
 
                   if (msg.msg_flags & MSG_CTRUNC) {
                     LOG(ERROR) << "SCM_RIGHTS message was truncated"
                                << " cmsg_len:" << cmsg->cmsg_len
                                << " fd:" << pipe_;
                     for (unsigned i = 0; i < num_wire_fds; ++i)
                       if (HANDLE_EINTR(close(wire_fds[i])) < 0)
                         PLOG(ERROR) << "close " << i;
@@ skipping 112 matching lines @@
 
   if (pipe_ == -1)
     return false;
 
   // Write out all the messages we can till the write blocks or there are no
   // more outgoing messages.
   while (!output_queue_.empty()) {
     Message* msg = output_queue_.front();
 
     size_t amt_to_write = msg->size() - message_send_bytes_written_;
-    DCHECK(amt_to_write != 0);
+    DCHECK_NE(0U, amt_to_write);
     const char* out_bytes = reinterpret_cast<const char*>(msg->data()) +
         message_send_bytes_written_;
 
     struct msghdr msgh = {0};
     struct iovec iov = {const_cast<char*>(out_bytes), amt_to_write};
     msgh.msg_iov = &iov;
     msgh.msg_iovlen = 1;
     char buf[CMSG_SPACE(
         sizeof(int[FileDescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE]))];
 
@@ skipping 267 matching lines @@
   // only send our handshake message after we've processed the client's.
   // This gives us a chance to kill the client if the incoming handshake
   // is invalid.
   if (send_server_hello_msg) {
     ProcessOutgoingMessages();
   }
 }
 
 // Called by libevent when we can write to the pipe without blocking.
 void Channel::ChannelImpl::OnFileCanWriteWithoutBlocking(int fd) {
-  DCHECK(fd == pipe_);
+  DCHECK_EQ(pipe_, fd);
   is_blocked_on_write_ = false;
   if (!ProcessOutgoingMessages()) {
     ClosePipeOnError();
   }
 }
 
 bool Channel::ChannelImpl::AcceptConnection() {
   MessageLoopForIO::current()->WatchFileDescriptor(pipe_,
                                                    true,
                                                    MessageLoopForIO::WATCH_READ,
@@ skipping 121 matching lines @@
 
 bool Channel::GetClientEuid(uid_t* client_euid) const {
   return channel_impl_->GetClientEuid(client_euid);
 }
 
 void Channel::ResetToAcceptingConnectionState() {
   channel_impl_->ResetToAcceptingConnectionState();
 }
 
 }  // namespace IPC