Add and use CheckedReadFD(), CheckedWriteFD(), and CheckedReadFDAtEOF()

util/mach/mach_message_server_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/mach/mach_message_server.h"
 
 #include <mach/mach.h>
 #include <string.h>
 
 #include "base/basictypes.h"
 #include "base/mac/scoped_mach_port.h"
 #include "gtest/gtest.h"
 #include "util/file/fd_io.h"
 #include "util/mach/mach_extensions.h"
-#include "util/test/errors.h"
 #include "util/test/mac/mach_errors.h"
 #include "util/test/mac/mach_multiprocess.h"
 
 namespace {
 
 using namespace crashpad;
 using namespace crashpad::test;
 
 class TestMachMessageServer : public MachMessageServer::Interface,
                               public MachMultiprocess {
@@ skipping 258 matching lines @@
   struct ReplyMessage : public mig_reply_error_t {
     uint32_t number;
   };
 
   // MachMultiprocess:
 
   virtual void MachMultiprocessParent() override {
     if (options_.parent_wait_for_child_pipe) {
       // Wait until the child is done sending what it’s going to send.
       char c;
-      ssize_t rv = ReadFD(ReadPipeFD(), &c, 1);
-      EXPECT_EQ(1, rv) << ErrnoMessage("read");
+      CheckedReadFD(ReadPipeFD(), &c, 1);
       EXPECT_EQ('\0', c);
     }
 
     kern_return_t kr;
     ASSERT_EQ(options_.expect_server_result,
               (kr = MachMessageServer::Run(this,
                                            LocalPort(),
                                            options_.server_options,
                                            options_.server_persistent,
                                            options_.server_nonblocking,
@@ skipping 25 matching lines @@
       // this test environment.
       kr = mach_port_type(
           mach_task_self(), parent_complex_message_port_, &type);
       EXPECT_EQ(KERN_INVALID_NAME, kr)
           << MachErrorMessage(kr, "mach_port_type");
     }
 
     if (options_.child_wait_for_parent_pipe) {
       // Let the child know it’s safe to exit.
       char c = '\0';
-      ssize_t rv = WriteFD(WritePipeFD(), &c, 1);
-      EXPECT_EQ(1, rv) << ErrnoMessage("write");
+      CheckedWriteFD(WritePipeFD(), &c, 1);
     }
   }
 
   virtual void MachMultiprocessChild() override {
     for (size_t index = 0;
          index < options_.client_send_request_count;
          ++index) {
       if (options_.child_send_all_requests_before_receiving_any_replies) {
         // For this test, all of the messages need to go into the queue before
         // the parent is allowed to start processing them. Don’t attempt to
@@ skipping 23 matching lines @@
            ++index) {
         ChildWaitForReply();
         if (testing::Test::HasFatalFailure()) {
           return;
         }
       }
     }
 
     if (options_.child_wait_for_parent_pipe) {
       char c;
-      ssize_t rv = ReadFD(ReadPipeFD(), &c, 1);
-      ASSERT_EQ(1, rv) << ErrnoMessage("read");
+      CheckedReadFD(ReadPipeFD(), &c, 1);
       ASSERT_EQ('\0', c);
     }
   }
 
   // In the child process, sends a request message to the server.
   void ChildSendRequest() {
     // local_receive_port_owner will the receive right that is created in this
     // scope and intended to be destroyed when leaving this scope, after it has
     // been carried in a Mach message.
     base::mac::ScopedMachReceiveRight local_receive_port_owner;
@@ skipping 107 matching lines @@
 
     ++replies_;
   }
 
   // For test types where the child needs to notify the server in the parent
   // that the child is ready, this method will send a byte via the POSIX pipe.
   // The parent will be waiting in a read() on this pipe, and will proceed to
   // running MachMessageServer() once it’s received.
   void ChildNotifyParentViaPipe() {
     char c = '\0';
-    ssize_t rv = WriteFD(WritePipeFD(), &c, 1);
-    ASSERT_EQ(1, rv) << ErrnoMessage("write");
+    CheckedWriteFD(WritePipeFD(), &c, 1);
   }
 
   // In the child process, sends a request message to the server and then
   // receives a reply message.
   void ChildSendRequestAndWaitForReply() {
     ChildSendRequest();
     if (testing::Test::HasFatalFailure()) {
       return;
     }
 
@@ skipping 262 matching lines @@
   // so a new buffer is allocated to receive the message. The server receives
   // the large request message, processes it, and returns a reply to the client.
   TestMachMessageServer::Options options;
   options.server_options = MACH_RCV_LARGE;
   options.client_send_large = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 }  // namespace